Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1 | //===-- SBValue.cpp ---------------------------------------------*- C++ -*-===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
Daniel Malea | 93a6430 | 2012-12-05 00:20:57 +0000 | [diff] [blame] | 10 | #include "lldb/lldb-python.h" |
| 11 | |
Eli Friedman | 4c5de69 | 2010-06-09 07:44:37 +0000 | [diff] [blame] | 12 | #include "lldb/API/SBValue.h" |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 13 | |
Enrico Granata | 10de090 | 2012-10-10 22:54:17 +0000 | [diff] [blame] | 14 | #include "lldb/API/SBDeclaration.h" |
Caroline Tice | dde9cff | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 15 | #include "lldb/API/SBStream.h" |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 16 | #include "lldb/API/SBTypeFilter.h" |
| 17 | #include "lldb/API/SBTypeFormat.h" |
| 18 | #include "lldb/API/SBTypeSummary.h" |
| 19 | #include "lldb/API/SBTypeSynthetic.h" |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 20 | |
Johnny Chen | 01a6786 | 2011-10-14 00:42:25 +0000 | [diff] [blame] | 21 | #include "lldb/Breakpoint/Watchpoint.h" |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 22 | #include "lldb/Core/DataExtractor.h" |
Caroline Tice | ceb6b13 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 23 | #include "lldb/Core/Log.h" |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 24 | #include "lldb/Core/Module.h" |
Greg Clayton | fe42ac4 | 2011-08-03 22:57:10 +0000 | [diff] [blame] | 25 | #include "lldb/Core/Scalar.h" |
Greg Clayton | 1f74607 | 2012-08-29 21:13:06 +0000 | [diff] [blame] | 26 | #include "lldb/Core/Section.h" |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 27 | #include "lldb/Core/Stream.h" |
| 28 | #include "lldb/Core/StreamFile.h" |
| 29 | #include "lldb/Core/Value.h" |
| 30 | #include "lldb/Core/ValueObject.h" |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 31 | #include "lldb/Core/ValueObjectConstResult.h" |
Enrico Granata | 5548cb5 | 2013-01-28 23:47:25 +0000 | [diff] [blame] | 32 | #include "lldb/DataFormatters/DataVisualization.h" |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 33 | #include "lldb/Symbol/Block.h" |
Enrico Granata | 10de090 | 2012-10-10 22:54:17 +0000 | [diff] [blame] | 34 | #include "lldb/Symbol/Declaration.h" |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 35 | #include "lldb/Symbol/ObjectFile.h" |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 36 | #include "lldb/Symbol/Type.h" |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 37 | #include "lldb/Symbol/Variable.h" |
Johnny Chen | 01a6786 | 2011-10-14 00:42:25 +0000 | [diff] [blame] | 38 | #include "lldb/Symbol/VariableList.h" |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 39 | #include "lldb/Target/ExecutionContext.h" |
| 40 | #include "lldb/Target/Process.h" |
Jason Molenda | b57e4a1 | 2013-11-04 09:33:30 +0000 | [diff] [blame] | 41 | #include "lldb/Target/StackFrame.h" |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 42 | #include "lldb/Target/Target.h" |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 43 | #include "lldb/Target/Thread.h" |
| 44 | |
Jim Ingham | 35e1bda | 2012-10-16 21:41:58 +0000 | [diff] [blame] | 45 | #include "lldb/API/SBDebugger.h" |
| 46 | #include "lldb/API/SBExpressionOptions.h" |
| 47 | #include "lldb/API/SBFrame.h" |
Eli Friedman | 4c5de69 | 2010-06-09 07:44:37 +0000 | [diff] [blame] | 48 | #include "lldb/API/SBProcess.h" |
| 49 | #include "lldb/API/SBTarget.h" |
| 50 | #include "lldb/API/SBThread.h" |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 51 | |
| 52 | using namespace lldb; |
| 53 | using namespace lldb_private; |
| 54 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 55 | class ValueImpl |
| 56 | { |
| 57 | public: |
| 58 | ValueImpl () |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 59 | { |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 60 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 61 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 62 | ValueImpl (lldb::ValueObjectSP in_valobj_sp, |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 63 | lldb::DynamicValueType use_dynamic, |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 64 | bool use_synthetic, |
| 65 | const char *name = NULL) : |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 66 | m_valobj_sp(in_valobj_sp), |
| 67 | m_use_dynamic(use_dynamic), |
| 68 | m_use_synthetic(use_synthetic), |
| 69 | m_name (name) |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 70 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 71 | if (!m_name.IsEmpty() && m_valobj_sp) |
| 72 | m_valobj_sp->SetName(m_name); |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 73 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 74 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 75 | ValueImpl (const ValueImpl& rhs) : |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 76 | m_valobj_sp(rhs.m_valobj_sp), |
| 77 | m_use_dynamic(rhs.m_use_dynamic), |
| 78 | m_use_synthetic(rhs.m_use_synthetic), |
| 79 | m_name (rhs.m_name) |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 80 | { |
| 81 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 82 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 83 | ValueImpl & |
| 84 | operator = (const ValueImpl &rhs) |
| 85 | { |
| 86 | if (this != &rhs) |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 87 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 88 | m_valobj_sp = rhs.m_valobj_sp; |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 89 | m_use_dynamic = rhs.m_use_dynamic; |
| 90 | m_use_synthetic = rhs.m_use_synthetic; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 91 | m_name = rhs.m_name; |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 92 | } |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 93 | return *this; |
| 94 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 95 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 96 | bool |
| 97 | IsValid () |
| 98 | { |
Jim Ingham | 793d8d9 | 2013-12-06 22:21:04 +0000 | [diff] [blame] | 99 | if (m_valobj_sp.get() == NULL) |
| 100 | return false; |
| 101 | else |
| 102 | { |
| 103 | // FIXME: This check is necessary but not sufficient. We for sure don't want to touch SBValues whose owning |
| 104 | // targets have gone away. This check is a little weak in that it enforces that restriction when you call |
| 105 | // IsValid, but since IsValid doesn't lock the target, you have no guarantee that the SBValue won't go |
| 106 | // invalid after you call this... |
| 107 | // Also, an SBValue could depend on data from one of the modules in the target, and those could go away |
| 108 | // independently of the target, for instance if a module is unloaded. But right now, neither SBValues |
| 109 | // nor ValueObjects know which modules they depend on. So I have no good way to make that check without |
| 110 | // tracking that in all the ValueObject subclasses. |
| 111 | TargetSP target_sp = m_valobj_sp->GetTargetSP(); |
| 112 | if (target_sp && target_sp->IsValid()) |
| 113 | return true; |
| 114 | else |
| 115 | return false; |
| 116 | } |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 117 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 118 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 119 | lldb::ValueObjectSP |
| 120 | GetRootSP () |
| 121 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 122 | return m_valobj_sp; |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 123 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 124 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 125 | lldb::ValueObjectSP |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 126 | GetSP (Process::StopLocker &stop_locker, Mutex::Locker &api_locker, Error &error) |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 127 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 128 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
| 129 | if (!m_valobj_sp) |
| 130 | { |
| 131 | error.SetErrorString("invalid value object"); |
| 132 | return m_valobj_sp; |
| 133 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 134 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 135 | lldb::ValueObjectSP value_sp = m_valobj_sp; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 136 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 137 | Target *target = value_sp->GetTargetSP().get(); |
| 138 | if (target) |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 139 | api_locker.Lock(target->GetAPIMutex()); |
Jim Ingham | 793d8d9 | 2013-12-06 22:21:04 +0000 | [diff] [blame] | 140 | else |
| 141 | return ValueObjectSP(); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 142 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 143 | ProcessSP process_sp(value_sp->GetProcessSP()); |
| 144 | if (process_sp && !stop_locker.TryLock (&process_sp->GetRunLock())) |
| 145 | { |
| 146 | // We don't allow people to play around with ValueObject if the process is running. |
| 147 | // If you want to look at values, pause the process, then look. |
| 148 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 149 | log->Printf ("SBValue(%p)::GetSP() => error: process is running", |
| 150 | static_cast<void*>(value_sp.get())); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 151 | error.SetErrorString ("process must be stopped."); |
| 152 | return ValueObjectSP(); |
| 153 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 154 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 155 | if (value_sp->GetDynamicValue(m_use_dynamic)) |
| 156 | value_sp = value_sp->GetDynamicValue(m_use_dynamic); |
| 157 | if (value_sp->GetSyntheticValue(m_use_synthetic)) |
| 158 | value_sp = value_sp->GetSyntheticValue(m_use_synthetic); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 159 | if (!value_sp) |
| 160 | error.SetErrorString("invalid value object"); |
| 161 | if (!m_name.IsEmpty()) |
| 162 | value_sp->SetName(m_name); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 163 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 164 | return value_sp; |
| 165 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 166 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 167 | void |
| 168 | SetUseDynamic (lldb::DynamicValueType use_dynamic) |
| 169 | { |
| 170 | m_use_dynamic = use_dynamic; |
| 171 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 172 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 173 | void |
| 174 | SetUseSynthetic (bool use_synthetic) |
| 175 | { |
| 176 | m_use_synthetic = use_synthetic; |
| 177 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 178 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 179 | lldb::DynamicValueType |
| 180 | GetUseDynamic () |
| 181 | { |
| 182 | return m_use_dynamic; |
| 183 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 184 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 185 | bool |
| 186 | GetUseSynthetic () |
| 187 | { |
| 188 | return m_use_synthetic; |
| 189 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 190 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 191 | // All the derived values that we would make from the m_valobj_sp will share |
| 192 | // the ExecutionContext with m_valobj_sp, so we don't need to do the calculations |
| 193 | // in GetSP to return the Target, Process, Thread or Frame. It is convenient to |
| 194 | // provide simple accessors for these, which I do here. |
| 195 | TargetSP |
| 196 | GetTargetSP () |
| 197 | { |
| 198 | if (m_valobj_sp) |
| 199 | return m_valobj_sp->GetTargetSP(); |
| 200 | else |
| 201 | return TargetSP(); |
| 202 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 203 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 204 | ProcessSP |
| 205 | GetProcessSP () |
| 206 | { |
| 207 | if (m_valobj_sp) |
| 208 | return m_valobj_sp->GetProcessSP(); |
| 209 | else |
| 210 | return ProcessSP(); |
| 211 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 212 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 213 | ThreadSP |
| 214 | GetThreadSP () |
| 215 | { |
| 216 | if (m_valobj_sp) |
| 217 | return m_valobj_sp->GetThreadSP(); |
| 218 | else |
| 219 | return ThreadSP(); |
| 220 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 221 | |
Jason Molenda | b57e4a1 | 2013-11-04 09:33:30 +0000 | [diff] [blame] | 222 | StackFrameSP |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 223 | GetFrameSP () |
| 224 | { |
| 225 | if (m_valobj_sp) |
| 226 | return m_valobj_sp->GetFrameSP(); |
| 227 | else |
Jason Molenda | b57e4a1 | 2013-11-04 09:33:30 +0000 | [diff] [blame] | 228 | return StackFrameSP(); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 229 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 230 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 231 | private: |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 232 | lldb::ValueObjectSP m_valobj_sp; |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 233 | lldb::DynamicValueType m_use_dynamic; |
| 234 | bool m_use_synthetic; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 235 | ConstString m_name; |
| 236 | }; |
| 237 | |
| 238 | class ValueLocker |
| 239 | { |
| 240 | public: |
| 241 | ValueLocker () |
| 242 | { |
| 243 | } |
| 244 | |
| 245 | ValueObjectSP |
| 246 | GetLockedSP(ValueImpl &in_value) |
| 247 | { |
| 248 | return in_value.GetSP(m_stop_locker, m_api_locker, m_lock_error); |
| 249 | } |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 250 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 251 | Error & |
| 252 | GetError() |
| 253 | { |
| 254 | return m_lock_error; |
| 255 | } |
| 256 | |
| 257 | private: |
| 258 | Process::StopLocker m_stop_locker; |
| 259 | Mutex::Locker m_api_locker; |
| 260 | Error m_lock_error; |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 261 | |
Enrico Granata | 19f0e8c | 2013-04-22 22:57:56 +0000 | [diff] [blame] | 262 | }; |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 263 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 264 | SBValue::SBValue () : |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 265 | m_opaque_sp () |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 266 | { |
| 267 | } |
| 268 | |
Enrico Granata | c5bc412 | 2012-03-27 02:35:13 +0000 | [diff] [blame] | 269 | SBValue::SBValue (const lldb::ValueObjectSP &value_sp) |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 270 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 271 | SetSP(value_sp); |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 272 | } |
| 273 | |
Enrico Granata | c5bc412 | 2012-03-27 02:35:13 +0000 | [diff] [blame] | 274 | SBValue::SBValue(const SBValue &rhs) |
Greg Clayton | efabb12 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 275 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 276 | SetSP(rhs.m_opaque_sp); |
Greg Clayton | efabb12 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 277 | } |
| 278 | |
Greg Clayton | bf2331c | 2011-09-09 23:04:00 +0000 | [diff] [blame] | 279 | SBValue & |
Greg Clayton | efabb12 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 280 | SBValue::operator = (const SBValue &rhs) |
| 281 | { |
| 282 | if (this != &rhs) |
Enrico Granata | c5bc412 | 2012-03-27 02:35:13 +0000 | [diff] [blame] | 283 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 284 | SetSP(rhs.m_opaque_sp); |
Enrico Granata | c5bc412 | 2012-03-27 02:35:13 +0000 | [diff] [blame] | 285 | } |
Greg Clayton | efabb12 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 286 | return *this; |
| 287 | } |
| 288 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 289 | SBValue::~SBValue() |
| 290 | { |
| 291 | } |
| 292 | |
| 293 | bool |
Greg Clayton | bf2331c | 2011-09-09 23:04:00 +0000 | [diff] [blame] | 294 | SBValue::IsValid () |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 295 | { |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 296 | // If this function ever changes to anything that does more than just |
| 297 | // check if the opaque shared pointer is non NULL, then we need to update |
| 298 | // all "if (m_opaque_sp)" code in this file. |
Jim Ingham | 793d8d9 | 2013-12-06 22:21:04 +0000 | [diff] [blame] | 299 | return m_opaque_sp.get() != NULL && m_opaque_sp->IsValid() && m_opaque_sp->GetRootSP().get() != NULL; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 300 | } |
| 301 | |
Jim Ingham | 5d3bca4 | 2011-12-19 20:39:44 +0000 | [diff] [blame] | 302 | void |
| 303 | SBValue::Clear() |
| 304 | { |
| 305 | m_opaque_sp.reset(); |
| 306 | } |
| 307 | |
Greg Clayton | 524e60b | 2010-10-06 22:10:17 +0000 | [diff] [blame] | 308 | SBError |
| 309 | SBValue::GetError() |
| 310 | { |
| 311 | SBError sb_error; |
| 312 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 313 | ValueLocker locker; |
| 314 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 315 | if (value_sp) |
| 316 | sb_error.SetError(value_sp->GetError()); |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 317 | else |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 318 | sb_error.SetErrorStringWithFormat ("error: %s", locker.GetError().AsCString()); |
Greg Clayton | 524e60b | 2010-10-06 22:10:17 +0000 | [diff] [blame] | 319 | |
| 320 | return sb_error; |
| 321 | } |
| 322 | |
Johnny Chen | b0b8be7 | 2011-07-07 20:46:23 +0000 | [diff] [blame] | 323 | user_id_t |
| 324 | SBValue::GetID() |
| 325 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 326 | ValueLocker locker; |
| 327 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 328 | if (value_sp) |
| 329 | return value_sp->GetID(); |
Johnny Chen | b0b8be7 | 2011-07-07 20:46:23 +0000 | [diff] [blame] | 330 | return LLDB_INVALID_UID; |
| 331 | } |
| 332 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 333 | const char * |
| 334 | SBValue::GetName() |
| 335 | { |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 336 | const char *name = NULL; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 337 | ValueLocker locker; |
| 338 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 339 | if (value_sp) |
| 340 | name = value_sp->GetName().GetCString(); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 341 | |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 342 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | 93aa84e | 2010-10-29 04:59:35 +0000 | [diff] [blame] | 343 | if (log) |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 344 | { |
| 345 | if (name) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 346 | log->Printf ("SBValue(%p)::GetName () => \"%s\"", |
| 347 | static_cast<void*>(value_sp.get()), name); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 348 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 349 | log->Printf ("SBValue(%p)::GetName () => NULL", |
| 350 | static_cast<void*>(value_sp.get())); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 351 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 352 | |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 353 | return name; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 354 | } |
| 355 | |
| 356 | const char * |
| 357 | SBValue::GetTypeName () |
| 358 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 359 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 360 | const char *name = NULL; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 361 | ValueLocker locker; |
| 362 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 363 | if (value_sp) |
Jim Ingham | 48cdc58 | 2012-08-21 01:46:35 +0000 | [diff] [blame] | 364 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 365 | name = value_sp->GetQualifiedTypeName().GetCString(); |
Jim Ingham | 48cdc58 | 2012-08-21 01:46:35 +0000 | [diff] [blame] | 366 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 367 | |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 368 | if (log) |
| 369 | { |
| 370 | if (name) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 371 | log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", |
| 372 | static_cast<void*>(value_sp.get()), name); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 373 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 374 | log->Printf ("SBValue(%p)::GetTypeName () => NULL", |
| 375 | static_cast<void*>(value_sp.get())); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 376 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 377 | |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 378 | return name; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 379 | } |
| 380 | |
Enrico Granata | e8daa2f | 2014-05-17 19:14:17 +0000 | [diff] [blame^] | 381 | const char * |
| 382 | SBValue::GetDisplayTypeName () |
| 383 | { |
| 384 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
| 385 | const char *name = NULL; |
| 386 | ValueLocker locker; |
| 387 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
| 388 | if (value_sp) |
| 389 | { |
| 390 | name = value_sp->GetDisplayTypeName().GetCString(); |
| 391 | } |
| 392 | |
| 393 | if (log) |
| 394 | { |
| 395 | if (name) |
| 396 | log->Printf ("SBValue(%p)::GetTypeName () => \"%s\"", |
| 397 | static_cast<void*>(value_sp.get()), name); |
| 398 | else |
| 399 | log->Printf ("SBValue(%p)::GetTypeName () => NULL", |
| 400 | static_cast<void*>(value_sp.get())); |
| 401 | } |
| 402 | |
| 403 | return name; |
| 404 | } |
| 405 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 406 | size_t |
| 407 | SBValue::GetByteSize () |
| 408 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 409 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 410 | size_t result = 0; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 411 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 412 | ValueLocker locker; |
| 413 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 414 | if (value_sp) |
Jim Ingham | 48cdc58 | 2012-08-21 01:46:35 +0000 | [diff] [blame] | 415 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 416 | result = value_sp->GetByteSize(); |
Jim Ingham | 48cdc58 | 2012-08-21 01:46:35 +0000 | [diff] [blame] | 417 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 418 | |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 419 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 420 | log->Printf ("SBValue(%p)::GetByteSize () => %" PRIu64, |
| 421 | static_cast<void*>(value_sp.get()), |
| 422 | static_cast<uint64_t>(result)); |
| 423 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 424 | return result; |
| 425 | } |
| 426 | |
| 427 | bool |
Jim Ingham | 6035b67 | 2011-03-31 00:19:25 +0000 | [diff] [blame] | 428 | SBValue::IsInScope () |
| 429 | { |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 430 | bool result = false; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 431 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 432 | ValueLocker locker; |
| 433 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 434 | if (value_sp) |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 435 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 436 | result = value_sp->IsInScope (); |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 437 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 438 | |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 439 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 440 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 441 | log->Printf ("SBValue(%p)::IsInScope () => %i", |
| 442 | static_cast<void*>(value_sp.get()), result); |
| 443 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 444 | return result; |
| 445 | } |
| 446 | |
| 447 | const char * |
Jim Ingham | 6035b67 | 2011-03-31 00:19:25 +0000 | [diff] [blame] | 448 | SBValue::GetValue () |
| 449 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 450 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 451 | |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 452 | const char *cstr = NULL; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 453 | ValueLocker locker; |
| 454 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 455 | if (value_sp) |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 456 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 457 | cstr = value_sp->GetValueAsCString (); |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 458 | } |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 459 | if (log) |
| 460 | { |
| 461 | if (cstr) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 462 | log->Printf ("SBValue(%p)::GetValue() => \"%s\"", |
| 463 | static_cast<void*>(value_sp.get()), cstr); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 464 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 465 | log->Printf ("SBValue(%p)::GetValue() => NULL", |
| 466 | static_cast<void*>(value_sp.get())); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 467 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 468 | |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 469 | return cstr; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 470 | } |
| 471 | |
Greg Clayton | 73b472d | 2010-10-27 03:32:59 +0000 | [diff] [blame] | 472 | ValueType |
| 473 | SBValue::GetValueType () |
| 474 | { |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 475 | ValueType result = eValueTypeInvalid; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 476 | ValueLocker locker; |
| 477 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 478 | if (value_sp) |
| 479 | result = value_sp->GetValueType(); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 480 | |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 481 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 482 | if (log) |
| 483 | { |
| 484 | switch (result) |
| 485 | { |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 486 | case eValueTypeInvalid: |
| 487 | log->Printf ("SBValue(%p)::GetValueType () => eValueTypeInvalid", |
| 488 | static_cast<void*>(value_sp.get())); |
| 489 | break; |
| 490 | case eValueTypeVariableGlobal: |
| 491 | log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableGlobal", |
| 492 | static_cast<void*>(value_sp.get())); |
| 493 | break; |
| 494 | case eValueTypeVariableStatic: |
| 495 | log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableStatic", |
| 496 | static_cast<void*>(value_sp.get())); |
| 497 | break; |
| 498 | case eValueTypeVariableArgument: |
| 499 | log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableArgument", |
| 500 | static_cast<void*>(value_sp.get())); |
| 501 | break; |
| 502 | case eValueTypeVariableLocal: |
| 503 | log->Printf ("SBValue(%p)::GetValueType () => eValueTypeVariableLocal", |
| 504 | static_cast<void*>(value_sp.get())); |
| 505 | break; |
| 506 | case eValueTypeRegister: |
| 507 | log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegister", |
| 508 | static_cast<void*>(value_sp.get())); |
| 509 | break; |
| 510 | case eValueTypeRegisterSet: |
| 511 | log->Printf ("SBValue(%p)::GetValueType () => eValueTypeRegisterSet", |
| 512 | static_cast<void*>(value_sp.get())); |
| 513 | break; |
| 514 | case eValueTypeConstResult: |
| 515 | log->Printf ("SBValue(%p)::GetValueType () => eValueTypeConstResult", |
| 516 | static_cast<void*>(value_sp.get())); |
| 517 | break; |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 518 | } |
| 519 | } |
| 520 | return result; |
Greg Clayton | 73b472d | 2010-10-27 03:32:59 +0000 | [diff] [blame] | 521 | } |
| 522 | |
Jim Ingham | 53c47f1 | 2010-09-10 23:12:17 +0000 | [diff] [blame] | 523 | const char * |
Jim Ingham | 6035b67 | 2011-03-31 00:19:25 +0000 | [diff] [blame] | 524 | SBValue::GetObjectDescription () |
| 525 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 526 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 527 | const char *cstr = NULL; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 528 | ValueLocker locker; |
| 529 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 530 | if (value_sp) |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 531 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 532 | cstr = value_sp->GetObjectDescription (); |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 533 | } |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 534 | if (log) |
| 535 | { |
| 536 | if (cstr) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 537 | log->Printf ("SBValue(%p)::GetObjectDescription() => \"%s\"", |
| 538 | static_cast<void*>(value_sp.get()), cstr); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 539 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 540 | log->Printf ("SBValue(%p)::GetObjectDescription() => NULL", |
| 541 | static_cast<void*>(value_sp.get())); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 542 | } |
| 543 | return cstr; |
Jim Ingham | 53c47f1 | 2010-09-10 23:12:17 +0000 | [diff] [blame] | 544 | } |
| 545 | |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 546 | SBType |
| 547 | SBValue::GetType() |
| 548 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 549 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 550 | SBType sb_type; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 551 | ValueLocker locker; |
| 552 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 553 | TypeImplSP type_sp; |
| 554 | if (value_sp) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 555 | { |
Enrico Granata | dc4db5a | 2013-10-29 00:28:35 +0000 | [diff] [blame] | 556 | type_sp.reset (new TypeImpl(value_sp->GetTypeImpl())); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 557 | sb_type.SetSP(type_sp); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 558 | } |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 559 | if (log) |
| 560 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 561 | if (type_sp) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 562 | log->Printf ("SBValue(%p)::GetType => SBType(%p)", |
| 563 | static_cast<void*>(value_sp.get()), |
| 564 | static_cast<void*>(type_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 565 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 566 | log->Printf ("SBValue(%p)::GetType => NULL", |
| 567 | static_cast<void*>(value_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 568 | } |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 569 | return sb_type; |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 570 | } |
| 571 | |
Jim Ingham | 6035b67 | 2011-03-31 00:19:25 +0000 | [diff] [blame] | 572 | bool |
| 573 | SBValue::GetValueDidChange () |
| 574 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 575 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 576 | bool result = false; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 577 | ValueLocker locker; |
| 578 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 579 | if (value_sp) |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 580 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 581 | result = value_sp->GetValueDidChange (); |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 582 | } |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 583 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 584 | log->Printf ("SBValue(%p)::GetValueDidChange() => %i", |
| 585 | static_cast<void*>(value_sp.get()), result); |
| 586 | |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 587 | return result; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 588 | } |
| 589 | |
Jason Molenda | cf7e2dc | 2012-02-21 05:33:55 +0000 | [diff] [blame] | 590 | #ifndef LLDB_DISABLE_PYTHON |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 591 | const char * |
Jim Ingham | 6035b67 | 2011-03-31 00:19:25 +0000 | [diff] [blame] | 592 | SBValue::GetSummary () |
| 593 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 594 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 595 | const char *cstr = NULL; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 596 | ValueLocker locker; |
| 597 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 598 | if (value_sp) |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 599 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 600 | cstr = value_sp->GetSummaryAsCString(); |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 601 | } |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 602 | if (log) |
| 603 | { |
| 604 | if (cstr) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 605 | log->Printf ("SBValue(%p)::GetSummary() => \"%s\"", |
| 606 | static_cast<void*>(value_sp.get()), cstr); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 607 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 608 | log->Printf ("SBValue(%p)::GetSummary() => NULL", |
| 609 | static_cast<void*>(value_sp.get())); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 610 | } |
| 611 | return cstr; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 612 | } |
Jason Molenda | cf7e2dc | 2012-02-21 05:33:55 +0000 | [diff] [blame] | 613 | #endif // LLDB_DISABLE_PYTHON |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 614 | |
| 615 | const char * |
Jim Ingham | 6035b67 | 2011-03-31 00:19:25 +0000 | [diff] [blame] | 616 | SBValue::GetLocation () |
| 617 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 618 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 619 | const char *cstr = NULL; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 620 | ValueLocker locker; |
| 621 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 622 | if (value_sp) |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 623 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 624 | cstr = value_sp->GetLocationAsCString(); |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 625 | } |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 626 | if (log) |
| 627 | { |
| 628 | if (cstr) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 629 | log->Printf ("SBValue(%p)::GetLocation() => \"%s\"", |
| 630 | static_cast<void*>(value_sp.get()), cstr); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 631 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 632 | log->Printf ("SBValue(%p)::GetLocation() => NULL", |
| 633 | static_cast<void*>(value_sp.get())); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 634 | } |
| 635 | return cstr; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 636 | } |
| 637 | |
Enrico Granata | 07a4ac2 | 2012-05-08 21:25:06 +0000 | [diff] [blame] | 638 | // Deprecated - use the one that takes an lldb::SBError |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 639 | bool |
Jim Ingham | 6035b67 | 2011-03-31 00:19:25 +0000 | [diff] [blame] | 640 | SBValue::SetValueFromCString (const char *value_str) |
| 641 | { |
Enrico Granata | 07a4ac2 | 2012-05-08 21:25:06 +0000 | [diff] [blame] | 642 | lldb::SBError dummy; |
| 643 | return SetValueFromCString(value_str,dummy); |
| 644 | } |
| 645 | |
| 646 | bool |
| 647 | SBValue::SetValueFromCString (const char *value_str, lldb::SBError& error) |
| 648 | { |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 649 | bool success = false; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 650 | ValueLocker locker; |
| 651 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 652 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 653 | if (value_sp) |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 654 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 655 | success = value_sp->SetValueFromCString (value_str,error.ref()); |
Greg Clayton | af67cec | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 656 | } |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 657 | else |
| 658 | error.SetErrorStringWithFormat ("Could not get value: %s", locker.GetError().AsCString()); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 659 | |
Greg Clayton | c9858e4 | 2012-04-06 02:17:47 +0000 | [diff] [blame] | 660 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 661 | log->Printf ("SBValue(%p)::SetValueFromCString(\"%s\") => %i", |
| 662 | static_cast<void*>(value_sp.get()), value_str, success); |
| 663 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 664 | return success; |
| 665 | } |
| 666 | |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 667 | lldb::SBTypeFormat |
| 668 | SBValue::GetTypeFormat () |
| 669 | { |
| 670 | lldb::SBTypeFormat format; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 671 | ValueLocker locker; |
| 672 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 673 | if (value_sp) |
| 674 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 675 | if (value_sp->UpdateValueIfNeeded(true)) |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 676 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 677 | lldb::TypeFormatImplSP format_sp = value_sp->GetValueFormat(); |
| 678 | if (format_sp) |
| 679 | format.SetSP(format_sp); |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 680 | } |
| 681 | } |
| 682 | return format; |
| 683 | } |
| 684 | |
Jason Molenda | cf7e2dc | 2012-02-21 05:33:55 +0000 | [diff] [blame] | 685 | #ifndef LLDB_DISABLE_PYTHON |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 686 | lldb::SBTypeSummary |
| 687 | SBValue::GetTypeSummary () |
| 688 | { |
| 689 | lldb::SBTypeSummary summary; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 690 | ValueLocker locker; |
| 691 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 692 | if (value_sp) |
| 693 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 694 | if (value_sp->UpdateValueIfNeeded(true)) |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 695 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 696 | lldb::TypeSummaryImplSP summary_sp = value_sp->GetSummaryFormat(); |
| 697 | if (summary_sp) |
| 698 | summary.SetSP(summary_sp); |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 699 | } |
| 700 | } |
| 701 | return summary; |
| 702 | } |
Jason Molenda | cf7e2dc | 2012-02-21 05:33:55 +0000 | [diff] [blame] | 703 | #endif // LLDB_DISABLE_PYTHON |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 704 | |
| 705 | lldb::SBTypeFilter |
| 706 | SBValue::GetTypeFilter () |
| 707 | { |
| 708 | lldb::SBTypeFilter filter; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 709 | ValueLocker locker; |
| 710 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 711 | if (value_sp) |
| 712 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 713 | if (value_sp->UpdateValueIfNeeded(true)) |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 714 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 715 | lldb::SyntheticChildrenSP synthetic_sp = value_sp->GetSyntheticChildren(); |
| 716 | |
| 717 | if (synthetic_sp && !synthetic_sp->IsScripted()) |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 718 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 719 | TypeFilterImplSP filter_sp = std::static_pointer_cast<TypeFilterImpl>(synthetic_sp); |
| 720 | filter.SetSP(filter_sp); |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 721 | } |
| 722 | } |
| 723 | } |
| 724 | return filter; |
| 725 | } |
| 726 | |
Jason Molenda | cf7e2dc | 2012-02-21 05:33:55 +0000 | [diff] [blame] | 727 | #ifndef LLDB_DISABLE_PYTHON |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 728 | lldb::SBTypeSynthetic |
| 729 | SBValue::GetTypeSynthetic () |
| 730 | { |
| 731 | lldb::SBTypeSynthetic synthetic; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 732 | ValueLocker locker; |
| 733 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 734 | if (value_sp) |
| 735 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 736 | if (value_sp->UpdateValueIfNeeded(true)) |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 737 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 738 | lldb::SyntheticChildrenSP children_sp = value_sp->GetSyntheticChildren(); |
| 739 | |
| 740 | if (children_sp && children_sp->IsScripted()) |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 741 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 742 | ScriptedSyntheticChildrenSP synth_sp = std::static_pointer_cast<ScriptedSyntheticChildren>(children_sp); |
| 743 | synthetic.SetSP(synth_sp); |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 744 | } |
| 745 | } |
| 746 | } |
| 747 | return synthetic; |
| 748 | } |
Jason Molenda | cf7e2dc | 2012-02-21 05:33:55 +0000 | [diff] [blame] | 749 | #endif |
Enrico Granata | 864e3e8 | 2012-02-17 03:18:30 +0000 | [diff] [blame] | 750 | |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 751 | lldb::SBValue |
Greg Clayton | bf2331c | 2011-09-09 23:04:00 +0000 | [diff] [blame] | 752 | SBValue::CreateChildAtOffset (const char *name, uint32_t offset, SBType type) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 753 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 754 | lldb::SBValue sb_value; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 755 | ValueLocker locker; |
| 756 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 757 | lldb::ValueObjectSP new_value_sp; |
| 758 | if (value_sp) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 759 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 760 | TypeImplSP type_sp (type.GetSP()); |
| 761 | if (type.IsValid()) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 762 | { |
Enrico Granata | dc4db5a | 2013-10-29 00:28:35 +0000 | [diff] [blame] | 763 | sb_value.SetSP(value_sp->GetSyntheticChildAtOffset(offset, type_sp->GetClangASTType(false), true),GetPreferDynamicValue(),GetPreferSyntheticValue(), name); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 764 | } |
| 765 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 766 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 767 | if (log) |
| 768 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 769 | if (new_value_sp) |
Jim Ingham | 35e1bda | 2012-10-16 21:41:58 +0000 | [diff] [blame] | 770 | log->Printf ("SBValue(%p)::CreateChildAtOffset => \"%s\"", |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 771 | static_cast<void*>(value_sp.get()), |
Jim Ingham | 35e1bda | 2012-10-16 21:41:58 +0000 | [diff] [blame] | 772 | new_value_sp->GetName().AsCString()); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 773 | else |
Jim Ingham | 35e1bda | 2012-10-16 21:41:58 +0000 | [diff] [blame] | 774 | log->Printf ("SBValue(%p)::CreateChildAtOffset => NULL", |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 775 | static_cast<void*>(value_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 776 | } |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 777 | return sb_value; |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 778 | } |
| 779 | |
| 780 | lldb::SBValue |
Greg Clayton | bf2331c | 2011-09-09 23:04:00 +0000 | [diff] [blame] | 781 | SBValue::Cast (SBType type) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 782 | { |
Greg Clayton | ef496d5 | 2012-01-31 04:25:15 +0000 | [diff] [blame] | 783 | lldb::SBValue sb_value; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 784 | ValueLocker locker; |
| 785 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 786 | TypeImplSP type_sp (type.GetSP()); |
| 787 | if (value_sp && type_sp) |
Enrico Granata | dc4db5a | 2013-10-29 00:28:35 +0000 | [diff] [blame] | 788 | sb_value.SetSP(value_sp->Cast(type_sp->GetClangASTType(false)),GetPreferDynamicValue(),GetPreferSyntheticValue()); |
Greg Clayton | ef496d5 | 2012-01-31 04:25:15 +0000 | [diff] [blame] | 789 | return sb_value; |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 790 | } |
| 791 | |
| 792 | lldb::SBValue |
| 793 | SBValue::CreateValueFromExpression (const char *name, const char* expression) |
| 794 | { |
Jim Ingham | 35e1bda | 2012-10-16 21:41:58 +0000 | [diff] [blame] | 795 | SBExpressionOptions options; |
Greg Clayton | cced156 | 2012-10-16 22:58:25 +0000 | [diff] [blame] | 796 | options.ref().SetKeepInMemory(true); |
Jim Ingham | 35e1bda | 2012-10-16 21:41:58 +0000 | [diff] [blame] | 797 | return CreateValueFromExpression (name, expression, options); |
| 798 | } |
| 799 | |
| 800 | lldb::SBValue |
| 801 | SBValue::CreateValueFromExpression (const char *name, const char *expression, SBExpressionOptions &options) |
| 802 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 803 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 804 | lldb::SBValue sb_value; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 805 | ValueLocker locker; |
| 806 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 807 | lldb::ValueObjectSP new_value_sp; |
| 808 | if (value_sp) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 809 | { |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 810 | ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 811 | Target* target = exe_ctx.GetTargetPtr(); |
| 812 | if (target) |
Johnny Chen | 5066044 | 2011-12-20 01:52:44 +0000 | [diff] [blame] | 813 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 814 | options.ref().SetKeepInMemory(true); |
| 815 | target->EvaluateExpression (expression, |
| 816 | exe_ctx.GetFramePtr(), |
| 817 | new_value_sp, |
| 818 | options.ref()); |
| 819 | if (new_value_sp) |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 820 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 821 | new_value_sp->SetName(ConstString(name)); |
| 822 | sb_value.SetSP(new_value_sp); |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 823 | } |
Johnny Chen | 5066044 | 2011-12-20 01:52:44 +0000 | [diff] [blame] | 824 | } |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 825 | } |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 826 | if (log) |
| 827 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 828 | if (new_value_sp) |
Greg Clayton | eac87f8 | 2012-06-04 20:13:23 +0000 | [diff] [blame] | 829 | log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => SBValue (%p)", |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 830 | static_cast<void*>(value_sp.get()), name, expression, |
| 831 | static_cast<void*>(new_value_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 832 | else |
Greg Clayton | eac87f8 | 2012-06-04 20:13:23 +0000 | [diff] [blame] | 833 | log->Printf ("SBValue(%p)::CreateValueFromExpression(name=\"%s\", expression=\"%s\") => NULL", |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 834 | static_cast<void*>(value_sp.get()), name, expression); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 835 | } |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 836 | return sb_value; |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 837 | } |
| 838 | |
| 839 | lldb::SBValue |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 840 | SBValue::CreateValueFromAddress(const char* name, lldb::addr_t address, SBType sb_type) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 841 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 842 | lldb::SBValue sb_value; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 843 | ValueLocker locker; |
| 844 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 845 | lldb::ValueObjectSP new_value_sp; |
| 846 | lldb::TypeImplSP type_impl_sp (sb_type.GetSP()); |
| 847 | if (value_sp && type_impl_sp) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 848 | { |
Enrico Granata | dc4db5a | 2013-10-29 00:28:35 +0000 | [diff] [blame] | 849 | ClangASTType pointer_ast_type(type_impl_sp->GetClangASTType(false).GetPointerType ()); |
Enrico Granata | 347c2aa | 2013-10-08 21:49:02 +0000 | [diff] [blame] | 850 | if (pointer_ast_type) |
Enrico Granata | 61408e0 | 2011-08-04 17:07:02 +0000 | [diff] [blame] | 851 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 852 | lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(&address,sizeof(lldb::addr_t))); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 853 | |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 854 | ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); |
| 855 | ValueObjectSP ptr_result_valobj_sp(ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), |
Enrico Granata | 347c2aa | 2013-10-08 21:49:02 +0000 | [diff] [blame] | 856 | pointer_ast_type, |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 857 | ConstString(name), |
| 858 | buffer, |
Enrico Granata | 347c2aa | 2013-10-08 21:49:02 +0000 | [diff] [blame] | 859 | exe_ctx.GetByteOrder(), |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 860 | exe_ctx.GetAddressByteSize())); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 861 | |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 862 | if (ptr_result_valobj_sp) |
| 863 | { |
| 864 | ptr_result_valobj_sp->GetValue().SetValueType(Value::eValueTypeLoadAddress); |
| 865 | Error err; |
| 866 | new_value_sp = ptr_result_valobj_sp->Dereference(err); |
| 867 | if (new_value_sp) |
| 868 | new_value_sp->SetName(ConstString(name)); |
| 869 | } |
| 870 | sb_value.SetSP(new_value_sp); |
Enrico Granata | 61408e0 | 2011-08-04 17:07:02 +0000 | [diff] [blame] | 871 | } |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 872 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 873 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 874 | if (log) |
| 875 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 876 | if (new_value_sp) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 877 | log->Printf ("SBValue(%p)::CreateValueFromAddress => \"%s\"", |
| 878 | static_cast<void*>(value_sp.get()), |
| 879 | new_value_sp->GetName().AsCString()); |
Johnny Chen | 4a871f9 | 2011-08-09 22:38:07 +0000 | [diff] [blame] | 880 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 881 | log->Printf ("SBValue(%p)::CreateValueFromAddress => NULL", |
| 882 | static_cast<void*>(value_sp.get())); |
Johnny Chen | 4a871f9 | 2011-08-09 22:38:07 +0000 | [diff] [blame] | 883 | } |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 884 | return sb_value; |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 885 | } |
| 886 | |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 887 | lldb::SBValue |
Greg Clayton | bf2331c | 2011-09-09 23:04:00 +0000 | [diff] [blame] | 888 | SBValue::CreateValueFromData (const char* name, SBData data, SBType type) |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 889 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 890 | lldb::SBValue sb_value; |
| 891 | lldb::ValueObjectSP new_value_sp; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 892 | ValueLocker locker; |
| 893 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 894 | if (value_sp) |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 895 | { |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 896 | ExecutionContext exe_ctx (value_sp->GetExecutionContextRef()); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 897 | |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 898 | new_value_sp = ValueObjectConstResult::Create (exe_ctx.GetBestExecutionContextScope(), |
Enrico Granata | dc4db5a | 2013-10-29 00:28:35 +0000 | [diff] [blame] | 899 | type.m_opaque_sp->GetClangASTType(false), |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 900 | ConstString(name), |
| 901 | *data.m_opaque_sp, |
| 902 | LLDB_INVALID_ADDRESS); |
| 903 | new_value_sp->SetAddressTypeOfChildren(eAddressTypeLoad); |
| 904 | sb_value.SetSP(new_value_sp); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 905 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 906 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 907 | if (log) |
| 908 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 909 | if (new_value_sp) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 910 | log->Printf ("SBValue(%p)::CreateValueFromData => \"%s\"", |
| 911 | static_cast<void*>(value_sp.get()), |
| 912 | new_value_sp->GetName().AsCString()); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 913 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 914 | log->Printf ("SBValue(%p)::CreateValueFromData => NULL", |
| 915 | static_cast<void*>(value_sp.get())); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 916 | } |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 917 | return sb_value; |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 918 | } |
| 919 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 920 | SBValue |
| 921 | SBValue::GetChildAtIndex (uint32_t idx) |
| 922 | { |
Greg Clayton | f6602482 | 2011-07-15 19:31:49 +0000 | [diff] [blame] | 923 | const bool can_create_synthetic = false; |
| 924 | lldb::DynamicValueType use_dynamic = eNoDynamicValues; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 925 | TargetSP target_sp; |
| 926 | if (m_opaque_sp) |
| 927 | target_sp = m_opaque_sp->GetTargetSP(); |
| 928 | |
| 929 | if (target_sp) |
| 930 | use_dynamic = target_sp->GetPreferDynamicValue(); |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 931 | |
Greg Clayton | f6602482 | 2011-07-15 19:31:49 +0000 | [diff] [blame] | 932 | return GetChildAtIndex (idx, use_dynamic, can_create_synthetic); |
Jim Ingham | 78a685a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 933 | } |
| 934 | |
| 935 | SBValue |
Greg Clayton | f6602482 | 2011-07-15 19:31:49 +0000 | [diff] [blame] | 936 | SBValue::GetChildAtIndex (uint32_t idx, lldb::DynamicValueType use_dynamic, bool can_create_synthetic) |
Jim Ingham | 78a685a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 937 | { |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 938 | lldb::ValueObjectSP child_sp; |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 939 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 940 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 941 | ValueLocker locker; |
| 942 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 943 | if (value_sp) |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 944 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 945 | const bool can_create = true; |
| 946 | child_sp = value_sp->GetChildAtIndex (idx, can_create); |
| 947 | if (can_create_synthetic && !child_sp) |
Greg Clayton | 626f4a1 | 2011-06-29 18:28:50 +0000 | [diff] [blame] | 948 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 949 | if (value_sp->IsPointerType()) |
Greg Clayton | 21c5ab4 | 2011-05-20 23:51:26 +0000 | [diff] [blame] | 950 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 951 | child_sp = value_sp->GetSyntheticArrayMemberFromPointer(idx, can_create); |
| 952 | } |
| 953 | else if (value_sp->IsArrayType()) |
| 954 | { |
| 955 | child_sp = value_sp->GetSyntheticArrayMemberFromArray(idx, can_create); |
Greg Clayton | 21c5ab4 | 2011-05-20 23:51:26 +0000 | [diff] [blame] | 956 | } |
Jim Ingham | 78a685a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 957 | } |
| 958 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 959 | |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 960 | SBValue sb_value; |
| 961 | sb_value.SetSP (child_sp, use_dynamic, GetPreferSyntheticValue()); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 962 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 963 | log->Printf ("SBValue(%p)::GetChildAtIndex (%u) => SBValue(%p)", |
| 964 | static_cast<void*>(value_sp.get()), idx, |
| 965 | static_cast<void*>(value_sp.get())); |
| 966 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 967 | return sb_value; |
| 968 | } |
| 969 | |
| 970 | uint32_t |
| 971 | SBValue::GetIndexOfChildWithName (const char *name) |
| 972 | { |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 973 | uint32_t idx = UINT32_MAX; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 974 | ValueLocker locker; |
| 975 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 976 | if (value_sp) |
Greg Clayton | 21c5ab4 | 2011-05-20 23:51:26 +0000 | [diff] [blame] | 977 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 978 | idx = value_sp->GetIndexOfChildWithName (ConstString(name)); |
Greg Clayton | 21c5ab4 | 2011-05-20 23:51:26 +0000 | [diff] [blame] | 979 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 980 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 981 | if (log) |
| 982 | { |
| 983 | if (idx == UINT32_MAX) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 984 | log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => NOT FOUND", |
| 985 | static_cast<void*>(value_sp.get()), name); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 986 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 987 | log->Printf ("SBValue(%p)::GetIndexOfChildWithName (name=\"%s\") => %u", |
| 988 | static_cast<void*>(value_sp.get()), name, idx); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 989 | } |
| 990 | return idx; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 991 | } |
| 992 | |
| 993 | SBValue |
| 994 | SBValue::GetChildMemberWithName (const char *name) |
| 995 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 996 | lldb::DynamicValueType use_dynamic_value = eNoDynamicValues; |
| 997 | TargetSP target_sp; |
| 998 | if (m_opaque_sp) |
| 999 | target_sp = m_opaque_sp->GetTargetSP(); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1000 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1001 | if (target_sp) |
| 1002 | use_dynamic_value = target_sp->GetPreferDynamicValue(); |
| 1003 | return GetChildMemberWithName (name, use_dynamic_value); |
Jim Ingham | 78a685a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 1004 | } |
| 1005 | |
| 1006 | SBValue |
Jim Ingham | 2837b76 | 2011-05-04 03:43:18 +0000 | [diff] [blame] | 1007 | SBValue::GetChildMemberWithName (const char *name, lldb::DynamicValueType use_dynamic_value) |
Jim Ingham | 78a685a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 1008 | { |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1009 | lldb::ValueObjectSP child_sp; |
| 1010 | const ConstString str_name (name); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1011 | |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1012 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1013 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1014 | ValueLocker locker; |
| 1015 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1016 | if (value_sp) |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1017 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1018 | child_sp = value_sp->GetChildMemberWithName (str_name, true); |
Jim Ingham | 78a685a | 2011-04-16 00:01:13 +0000 | [diff] [blame] | 1019 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1020 | |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1021 | SBValue sb_value; |
| 1022 | sb_value.SetSP(child_sp, use_dynamic_value, GetPreferSyntheticValue()); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1023 | |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 1024 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1025 | log->Printf ("SBValue(%p)::GetChildMemberWithName (name=\"%s\") => SBValue(%p)", |
| 1026 | static_cast<void*>(value_sp.get()), name, |
| 1027 | static_cast<void*>(value_sp.get())); |
| 1028 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1029 | return sb_value; |
| 1030 | } |
| 1031 | |
Enrico Granata | f2bbf71 | 2011-07-15 02:26:42 +0000 | [diff] [blame] | 1032 | lldb::SBValue |
Jim Ingham | 60dbabb | 2011-12-08 19:44:08 +0000 | [diff] [blame] | 1033 | SBValue::GetDynamicValue (lldb::DynamicValueType use_dynamic) |
| 1034 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1035 | SBValue value_sb; |
| 1036 | if (IsValid()) |
Jim Ingham | 60dbabb | 2011-12-08 19:44:08 +0000 | [diff] [blame] | 1037 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1038 | ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),use_dynamic,m_opaque_sp->GetUseSynthetic())); |
| 1039 | value_sb.SetSP(proxy_sp); |
Jim Ingham | 60dbabb | 2011-12-08 19:44:08 +0000 | [diff] [blame] | 1040 | } |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1041 | return value_sb; |
Jim Ingham | 60dbabb | 2011-12-08 19:44:08 +0000 | [diff] [blame] | 1042 | } |
| 1043 | |
| 1044 | lldb::SBValue |
| 1045 | SBValue::GetStaticValue () |
| 1046 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1047 | SBValue value_sb; |
| 1048 | if (IsValid()) |
Jim Ingham | 60dbabb | 2011-12-08 19:44:08 +0000 | [diff] [blame] | 1049 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1050 | ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),eNoDynamicValues,m_opaque_sp->GetUseSynthetic())); |
| 1051 | value_sb.SetSP(proxy_sp); |
Jim Ingham | 60dbabb | 2011-12-08 19:44:08 +0000 | [diff] [blame] | 1052 | } |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1053 | return value_sb; |
Jim Ingham | 60dbabb | 2011-12-08 19:44:08 +0000 | [diff] [blame] | 1054 | } |
| 1055 | |
Enrico Granata | c5bc412 | 2012-03-27 02:35:13 +0000 | [diff] [blame] | 1056 | lldb::SBValue |
| 1057 | SBValue::GetNonSyntheticValue () |
| 1058 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1059 | SBValue value_sb; |
| 1060 | if (IsValid()) |
Enrico Granata | c5bc412 | 2012-03-27 02:35:13 +0000 | [diff] [blame] | 1061 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1062 | ValueImplSP proxy_sp(new ValueImpl(m_opaque_sp->GetRootSP(),m_opaque_sp->GetUseDynamic(),false)); |
| 1063 | value_sb.SetSP(proxy_sp); |
Enrico Granata | c5bc412 | 2012-03-27 02:35:13 +0000 | [diff] [blame] | 1064 | } |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1065 | return value_sb; |
| 1066 | } |
| 1067 | |
| 1068 | lldb::DynamicValueType |
| 1069 | SBValue::GetPreferDynamicValue () |
| 1070 | { |
| 1071 | if (!IsValid()) |
| 1072 | return eNoDynamicValues; |
| 1073 | return m_opaque_sp->GetUseDynamic(); |
| 1074 | } |
| 1075 | |
| 1076 | void |
| 1077 | SBValue::SetPreferDynamicValue (lldb::DynamicValueType use_dynamic) |
| 1078 | { |
| 1079 | if (IsValid()) |
| 1080 | return m_opaque_sp->SetUseDynamic (use_dynamic); |
| 1081 | } |
| 1082 | |
| 1083 | bool |
| 1084 | SBValue::GetPreferSyntheticValue () |
| 1085 | { |
| 1086 | if (!IsValid()) |
| 1087 | return false; |
| 1088 | return m_opaque_sp->GetUseSynthetic(); |
| 1089 | } |
| 1090 | |
| 1091 | void |
| 1092 | SBValue::SetPreferSyntheticValue (bool use_synthetic) |
| 1093 | { |
| 1094 | if (IsValid()) |
| 1095 | return m_opaque_sp->SetUseSynthetic (use_synthetic); |
Enrico Granata | c5bc412 | 2012-03-27 02:35:13 +0000 | [diff] [blame] | 1096 | } |
| 1097 | |
Jim Ingham | 60dbabb | 2011-12-08 19:44:08 +0000 | [diff] [blame] | 1098 | bool |
| 1099 | SBValue::IsDynamic() |
| 1100 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1101 | ValueLocker locker; |
| 1102 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1103 | if (value_sp) |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1104 | return value_sp->IsDynamic(); |
Jim Ingham | 60dbabb | 2011-12-08 19:44:08 +0000 | [diff] [blame] | 1105 | return false; |
| 1106 | } |
| 1107 | |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1108 | bool |
| 1109 | SBValue::IsSynthetic () |
| 1110 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1111 | ValueLocker locker; |
| 1112 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1113 | if (value_sp) |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1114 | return value_sp->IsSynthetic(); |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1115 | return false; |
| 1116 | } |
| 1117 | |
Jim Ingham | 60dbabb | 2011-12-08 19:44:08 +0000 | [diff] [blame] | 1118 | lldb::SBValue |
Enrico Granata | f2bbf71 | 2011-07-15 02:26:42 +0000 | [diff] [blame] | 1119 | SBValue::GetValueForExpressionPath(const char* expr_path) |
| 1120 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1121 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | f2bbf71 | 2011-07-15 02:26:42 +0000 | [diff] [blame] | 1122 | lldb::ValueObjectSP child_sp; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1123 | ValueLocker locker; |
| 1124 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1125 | if (value_sp) |
Enrico Granata | f2bbf71 | 2011-07-15 02:26:42 +0000 | [diff] [blame] | 1126 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1127 | // using default values for all the fancy options, just do it if you can |
| 1128 | child_sp = value_sp->GetValueForExpressionPath(expr_path); |
Enrico Granata | f2bbf71 | 2011-07-15 02:26:42 +0000 | [diff] [blame] | 1129 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1130 | |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1131 | SBValue sb_value; |
| 1132 | sb_value.SetSP(child_sp,GetPreferDynamicValue(),GetPreferSyntheticValue()); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1133 | |
Enrico Granata | f2bbf71 | 2011-07-15 02:26:42 +0000 | [diff] [blame] | 1134 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1135 | log->Printf ("SBValue(%p)::GetValueForExpressionPath (expr_path=\"%s\") => SBValue(%p)", |
| 1136 | static_cast<void*>(value_sp.get()), expr_path, |
| 1137 | static_cast<void*>(value_sp.get())); |
| 1138 | |
Enrico Granata | f2bbf71 | 2011-07-15 02:26:42 +0000 | [diff] [blame] | 1139 | return sb_value; |
| 1140 | } |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1141 | |
Greg Clayton | fe42ac4 | 2011-08-03 22:57:10 +0000 | [diff] [blame] | 1142 | int64_t |
Enrico Granata | 6fd87d5 | 2011-08-04 01:41:02 +0000 | [diff] [blame] | 1143 | SBValue::GetValueAsSigned(SBError& error, int64_t fail_value) |
| 1144 | { |
Jim Ingham | 16e0c68 | 2011-08-12 23:34:31 +0000 | [diff] [blame] | 1145 | error.Clear(); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1146 | ValueLocker locker; |
| 1147 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1148 | if (value_sp) |
Enrico Granata | 6fd87d5 | 2011-08-04 01:41:02 +0000 | [diff] [blame] | 1149 | { |
Enrico Granata | d7373f6 | 2013-10-31 18:57:50 +0000 | [diff] [blame] | 1150 | bool success = true; |
| 1151 | uint64_t ret_val = fail_value; |
| 1152 | ret_val = value_sp->GetValueAsSigned(fail_value, &success); |
| 1153 | if (!success) |
| 1154 | error.SetErrorString("could not resolve value"); |
| 1155 | return ret_val; |
Enrico Granata | 6fd87d5 | 2011-08-04 01:41:02 +0000 | [diff] [blame] | 1156 | } |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1157 | else |
| 1158 | error.SetErrorStringWithFormat ("could not get SBValue: %s", locker.GetError().AsCString()); |
| 1159 | |
Enrico Granata | 6fd87d5 | 2011-08-04 01:41:02 +0000 | [diff] [blame] | 1160 | return fail_value; |
| 1161 | } |
| 1162 | |
| 1163 | uint64_t |
| 1164 | SBValue::GetValueAsUnsigned(SBError& error, uint64_t fail_value) |
| 1165 | { |
Jim Ingham | 16e0c68 | 2011-08-12 23:34:31 +0000 | [diff] [blame] | 1166 | error.Clear(); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1167 | ValueLocker locker; |
| 1168 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1169 | if (value_sp) |
Enrico Granata | 6fd87d5 | 2011-08-04 01:41:02 +0000 | [diff] [blame] | 1170 | { |
Enrico Granata | d7373f6 | 2013-10-31 18:57:50 +0000 | [diff] [blame] | 1171 | bool success = true; |
| 1172 | uint64_t ret_val = fail_value; |
| 1173 | ret_val = value_sp->GetValueAsUnsigned(fail_value, &success); |
| 1174 | if (!success) |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1175 | error.SetErrorString("could not resolve value"); |
Enrico Granata | d7373f6 | 2013-10-31 18:57:50 +0000 | [diff] [blame] | 1176 | return ret_val; |
Enrico Granata | 6fd87d5 | 2011-08-04 01:41:02 +0000 | [diff] [blame] | 1177 | } |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1178 | else |
| 1179 | error.SetErrorStringWithFormat ("could not get SBValue: %s", locker.GetError().AsCString()); |
| 1180 | |
Enrico Granata | 6fd87d5 | 2011-08-04 01:41:02 +0000 | [diff] [blame] | 1181 | return fail_value; |
| 1182 | } |
| 1183 | |
| 1184 | int64_t |
Greg Clayton | fe42ac4 | 2011-08-03 22:57:10 +0000 | [diff] [blame] | 1185 | SBValue::GetValueAsSigned(int64_t fail_value) |
| 1186 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1187 | ValueLocker locker; |
| 1188 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1189 | if (value_sp) |
Greg Clayton | fe42ac4 | 2011-08-03 22:57:10 +0000 | [diff] [blame] | 1190 | { |
Enrico Granata | d7373f6 | 2013-10-31 18:57:50 +0000 | [diff] [blame] | 1191 | return value_sp->GetValueAsSigned(fail_value); |
Greg Clayton | fe42ac4 | 2011-08-03 22:57:10 +0000 | [diff] [blame] | 1192 | } |
| 1193 | return fail_value; |
| 1194 | } |
| 1195 | |
| 1196 | uint64_t |
| 1197 | SBValue::GetValueAsUnsigned(uint64_t fail_value) |
| 1198 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1199 | ValueLocker locker; |
| 1200 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1201 | if (value_sp) |
Greg Clayton | fe42ac4 | 2011-08-03 22:57:10 +0000 | [diff] [blame] | 1202 | { |
Enrico Granata | d7373f6 | 2013-10-31 18:57:50 +0000 | [diff] [blame] | 1203 | return value_sp->GetValueAsUnsigned(fail_value); |
Greg Clayton | fe42ac4 | 2011-08-03 22:57:10 +0000 | [diff] [blame] | 1204 | } |
| 1205 | return fail_value; |
| 1206 | } |
| 1207 | |
Greg Clayton | 4a79207 | 2012-10-23 01:50:10 +0000 | [diff] [blame] | 1208 | bool |
| 1209 | SBValue::MightHaveChildren () |
| 1210 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1211 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | 4a79207 | 2012-10-23 01:50:10 +0000 | [diff] [blame] | 1212 | bool has_children = false; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1213 | ValueLocker locker; |
| 1214 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 4a79207 | 2012-10-23 01:50:10 +0000 | [diff] [blame] | 1215 | if (value_sp) |
| 1216 | has_children = value_sp->MightHaveChildren(); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1217 | |
Greg Clayton | 4a79207 | 2012-10-23 01:50:10 +0000 | [diff] [blame] | 1218 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1219 | log->Printf ("SBValue(%p)::MightHaveChildren() => %i", |
| 1220 | static_cast<void*>(value_sp.get()), has_children); |
Greg Clayton | 4a79207 | 2012-10-23 01:50:10 +0000 | [diff] [blame] | 1221 | return has_children; |
| 1222 | } |
| 1223 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1224 | uint32_t |
| 1225 | SBValue::GetNumChildren () |
| 1226 | { |
| 1227 | uint32_t num_children = 0; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1228 | |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1229 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1230 | ValueLocker locker; |
| 1231 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1232 | if (value_sp) |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1233 | num_children = value_sp->GetNumChildren(); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1234 | |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 1235 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1236 | log->Printf ("SBValue(%p)::GetNumChildren () => %u", |
| 1237 | static_cast<void*>(value_sp.get()), num_children); |
| 1238 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1239 | return num_children; |
| 1240 | } |
| 1241 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1242 | |
| 1243 | SBValue |
| 1244 | SBValue::Dereference () |
| 1245 | { |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 1246 | SBValue sb_value; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1247 | ValueLocker locker; |
| 1248 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1249 | if (value_sp) |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1250 | { |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 1251 | Error error; |
| 1252 | sb_value = value_sp->Dereference (error); |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1253 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1254 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 1255 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1256 | log->Printf ("SBValue(%p)::Dereference () => SBValue(%p)", |
| 1257 | static_cast<void*>(value_sp.get()), |
| 1258 | static_cast<void*>(value_sp.get())); |
| 1259 | |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 1260 | return sb_value; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1261 | } |
| 1262 | |
| 1263 | bool |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 1264 | SBValue::TypeIsPointerType () |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1265 | { |
| 1266 | bool is_ptr_type = false; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1267 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1268 | ValueLocker locker; |
| 1269 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1270 | if (value_sp) |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1271 | is_ptr_type = value_sp->IsPointerType(); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1272 | |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1273 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 1274 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1275 | log->Printf ("SBValue(%p)::TypeIsPointerType () => %i", |
| 1276 | static_cast<void*>(value_sp.get()), is_ptr_type); |
| 1277 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1278 | return is_ptr_type; |
| 1279 | } |
| 1280 | |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1281 | void * |
| 1282 | SBValue::GetOpaqueType() |
| 1283 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1284 | ValueLocker locker; |
| 1285 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1286 | if (value_sp) |
Greg Clayton | 57ee306 | 2013-07-11 22:46:58 +0000 | [diff] [blame] | 1287 | return value_sp->GetClangType().GetOpaqueQualType(); |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1288 | return NULL; |
| 1289 | } |
| 1290 | |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1291 | lldb::SBTarget |
| 1292 | SBValue::GetTarget() |
| 1293 | { |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 1294 | SBTarget sb_target; |
| 1295 | TargetSP target_sp; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1296 | if (m_opaque_sp) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1297 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1298 | target_sp = m_opaque_sp->GetTargetSP(); |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 1299 | sb_target.SetSP (target_sp); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1300 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1301 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1302 | if (log) |
| 1303 | { |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 1304 | if (target_sp.get() == NULL) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1305 | log->Printf ("SBValue(%p)::GetTarget () => NULL", |
| 1306 | static_cast<void*>(m_opaque_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1307 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1308 | log->Printf ("SBValue(%p)::GetTarget () => %p", |
| 1309 | static_cast<void*>(m_opaque_sp.get()), |
| 1310 | static_cast<void*>(target_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1311 | } |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 1312 | return sb_target; |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1313 | } |
| 1314 | |
| 1315 | lldb::SBProcess |
| 1316 | SBValue::GetProcess() |
| 1317 | { |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 1318 | SBProcess sb_process; |
| 1319 | ProcessSP process_sp; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1320 | if (m_opaque_sp) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1321 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1322 | process_sp = m_opaque_sp->GetProcessSP(); |
| 1323 | sb_process.SetSP (process_sp); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1324 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1325 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1326 | if (log) |
| 1327 | { |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 1328 | if (process_sp.get() == NULL) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1329 | log->Printf ("SBValue(%p)::GetProcess () => NULL", |
| 1330 | static_cast<void*>(m_opaque_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1331 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1332 | log->Printf ("SBValue(%p)::GetProcess () => %p", |
| 1333 | static_cast<void*>(m_opaque_sp.get()), |
| 1334 | static_cast<void*>(process_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1335 | } |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 1336 | return sb_process; |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1337 | } |
| 1338 | |
| 1339 | lldb::SBThread |
| 1340 | SBValue::GetThread() |
| 1341 | { |
Greg Clayton | 17a6ad0 | 2012-01-30 02:53:15 +0000 | [diff] [blame] | 1342 | SBThread sb_thread; |
| 1343 | ThreadSP thread_sp; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1344 | if (m_opaque_sp) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1345 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1346 | thread_sp = m_opaque_sp->GetThreadSP(); |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 1347 | sb_thread.SetThread(thread_sp); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1348 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1349 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1350 | if (log) |
| 1351 | { |
Greg Clayton | 17a6ad0 | 2012-01-30 02:53:15 +0000 | [diff] [blame] | 1352 | if (thread_sp.get() == NULL) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1353 | log->Printf ("SBValue(%p)::GetThread () => NULL", |
| 1354 | static_cast<void*>(m_opaque_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1355 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1356 | log->Printf ("SBValue(%p)::GetThread () => %p", |
| 1357 | static_cast<void*>(m_opaque_sp.get()), |
| 1358 | static_cast<void*>(thread_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1359 | } |
Greg Clayton | 17a6ad0 | 2012-01-30 02:53:15 +0000 | [diff] [blame] | 1360 | return sb_thread; |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1361 | } |
| 1362 | |
| 1363 | lldb::SBFrame |
| 1364 | SBValue::GetFrame() |
| 1365 | { |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 1366 | SBFrame sb_frame; |
Jason Molenda | b57e4a1 | 2013-11-04 09:33:30 +0000 | [diff] [blame] | 1367 | StackFrameSP frame_sp; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1368 | if (m_opaque_sp) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1369 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1370 | frame_sp = m_opaque_sp->GetFrameSP(); |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 1371 | sb_frame.SetFrameSP (frame_sp); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1372 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1373 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1374 | if (log) |
| 1375 | { |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 1376 | if (frame_sp.get() == NULL) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1377 | log->Printf ("SBValue(%p)::GetFrame () => NULL", |
| 1378 | static_cast<void*>(m_opaque_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1379 | else |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1380 | log->Printf ("SBValue(%p)::GetFrame () => %p", |
| 1381 | static_cast<void*>(m_opaque_sp.get()), |
| 1382 | static_cast<void*>(frame_sp.get())); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1383 | } |
Greg Clayton | b9556ac | 2012-01-30 07:41:31 +0000 | [diff] [blame] | 1384 | return sb_frame; |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1385 | } |
| 1386 | |
| 1387 | |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1388 | lldb::ValueObjectSP |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1389 | SBValue::GetSP (ValueLocker &locker) const |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1390 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1391 | if (!m_opaque_sp || !m_opaque_sp->IsValid()) |
| 1392 | return ValueObjectSP(); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1393 | return locker.GetLockedSP(*m_opaque_sp.get()); |
| 1394 | } |
| 1395 | |
| 1396 | lldb::ValueObjectSP |
| 1397 | SBValue::GetSP () const |
| 1398 | { |
| 1399 | ValueLocker locker; |
| 1400 | return GetSP(locker); |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1401 | } |
| 1402 | |
| 1403 | void |
| 1404 | SBValue::SetSP (ValueImplSP impl_sp) |
| 1405 | { |
| 1406 | m_opaque_sp = impl_sp; |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1407 | } |
| 1408 | |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1409 | void |
| 1410 | SBValue::SetSP (const lldb::ValueObjectSP &sp) |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1411 | { |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1412 | if (sp) |
| 1413 | { |
| 1414 | lldb::TargetSP target_sp(sp->GetTargetSP()); |
| 1415 | if (target_sp) |
| 1416 | { |
| 1417 | lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue(); |
| 1418 | bool use_synthetic = target_sp->TargetProperties::GetEnableSyntheticValue(); |
| 1419 | m_opaque_sp = ValueImplSP(new ValueImpl(sp, use_dynamic, use_synthetic)); |
| 1420 | } |
| 1421 | else |
| 1422 | m_opaque_sp = ValueImplSP(new ValueImpl(sp,eNoDynamicValues,true)); |
| 1423 | } |
| 1424 | else |
| 1425 | m_opaque_sp = ValueImplSP(new ValueImpl(sp,eNoDynamicValues,false)); |
Chris Lattner | 30fdc8d | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1426 | } |
Caroline Tice | dde9cff | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 1427 | |
Enrico Granata | e3e9151 | 2012-10-22 18:18:36 +0000 | [diff] [blame] | 1428 | void |
| 1429 | SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic) |
| 1430 | { |
| 1431 | if (sp) |
| 1432 | { |
| 1433 | lldb::TargetSP target_sp(sp->GetTargetSP()); |
| 1434 | if (target_sp) |
| 1435 | { |
| 1436 | bool use_synthetic = target_sp->TargetProperties::GetEnableSyntheticValue(); |
| 1437 | SetSP (sp, use_dynamic, use_synthetic); |
| 1438 | } |
| 1439 | else |
| 1440 | SetSP (sp, use_dynamic, true); |
| 1441 | } |
| 1442 | else |
| 1443 | SetSP (sp, use_dynamic, false); |
| 1444 | } |
| 1445 | |
| 1446 | void |
| 1447 | SBValue::SetSP (const lldb::ValueObjectSP &sp, bool use_synthetic) |
| 1448 | { |
| 1449 | if (sp) |
| 1450 | { |
| 1451 | lldb::TargetSP target_sp(sp->GetTargetSP()); |
| 1452 | if (target_sp) |
| 1453 | { |
| 1454 | lldb::DynamicValueType use_dynamic = target_sp->GetPreferDynamicValue(); |
| 1455 | SetSP (sp, use_dynamic, use_synthetic); |
| 1456 | } |
| 1457 | else |
| 1458 | SetSP (sp, eNoDynamicValues, use_synthetic); |
| 1459 | } |
| 1460 | else |
| 1461 | SetSP (sp, eNoDynamicValues, use_synthetic); |
| 1462 | } |
| 1463 | |
| 1464 | void |
| 1465 | SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic) |
| 1466 | { |
| 1467 | m_opaque_sp = ValueImplSP(new ValueImpl(sp,use_dynamic,use_synthetic)); |
| 1468 | } |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1469 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1470 | void |
| 1471 | SBValue::SetSP (const lldb::ValueObjectSP &sp, lldb::DynamicValueType use_dynamic, bool use_synthetic, const char *name) |
| 1472 | { |
| 1473 | m_opaque_sp = ValueImplSP(new ValueImpl(sp,use_dynamic,use_synthetic, name)); |
| 1474 | } |
| 1475 | |
Caroline Tice | dde9cff | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 1476 | bool |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 1477 | SBValue::GetExpressionPath (SBStream &description) |
| 1478 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1479 | ValueLocker locker; |
| 1480 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1481 | if (value_sp) |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 1482 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1483 | value_sp->GetExpressionPath (description.ref(), false); |
Greg Clayton | 6beaaa6 | 2011-01-17 03:46:26 +0000 | [diff] [blame] | 1484 | return true; |
| 1485 | } |
| 1486 | return false; |
| 1487 | } |
| 1488 | |
| 1489 | bool |
| 1490 | SBValue::GetExpressionPath (SBStream &description, bool qualify_cxx_base_classes) |
| 1491 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1492 | ValueLocker locker; |
| 1493 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1494 | if (value_sp) |
Greg Clayton | 6beaaa6 | 2011-01-17 03:46:26 +0000 | [diff] [blame] | 1495 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1496 | value_sp->GetExpressionPath (description.ref(), qualify_cxx_base_classes); |
Greg Clayton | cfd1ace | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 1497 | return true; |
| 1498 | } |
| 1499 | return false; |
| 1500 | } |
| 1501 | |
| 1502 | bool |
Caroline Tice | dde9cff | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 1503 | SBValue::GetDescription (SBStream &description) |
| 1504 | { |
Greg Clayton | da7bc7d | 2011-11-13 06:57:31 +0000 | [diff] [blame] | 1505 | Stream &strm = description.ref(); |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 1506 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1507 | ValueLocker locker; |
| 1508 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1509 | if (value_sp) |
Enrico Granata | 4d93b8c | 2013-09-30 19:11:51 +0000 | [diff] [blame] | 1510 | value_sp->Dump(strm); |
Caroline Tice | dde9cff | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 1511 | else |
Greg Clayton | da7bc7d | 2011-11-13 06:57:31 +0000 | [diff] [blame] | 1512 | strm.PutCString ("No value"); |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 1513 | |
Caroline Tice | dde9cff | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 1514 | return true; |
| 1515 | } |
Greg Clayton | dc4e963 | 2011-01-05 18:43:15 +0000 | [diff] [blame] | 1516 | |
| 1517 | lldb::Format |
Greg Clayton | bf2331c | 2011-09-09 23:04:00 +0000 | [diff] [blame] | 1518 | SBValue::GetFormat () |
Greg Clayton | dc4e963 | 2011-01-05 18:43:15 +0000 | [diff] [blame] | 1519 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1520 | ValueLocker locker; |
| 1521 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1522 | if (value_sp) |
| 1523 | return value_sp->GetFormat(); |
Greg Clayton | dc4e963 | 2011-01-05 18:43:15 +0000 | [diff] [blame] | 1524 | return eFormatDefault; |
| 1525 | } |
| 1526 | |
| 1527 | void |
| 1528 | SBValue::SetFormat (lldb::Format format) |
| 1529 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1530 | ValueLocker locker; |
| 1531 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1532 | if (value_sp) |
| 1533 | value_sp->SetFormat(format); |
Greg Clayton | dc4e963 | 2011-01-05 18:43:15 +0000 | [diff] [blame] | 1534 | } |
| 1535 | |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1536 | lldb::SBValue |
| 1537 | SBValue::AddressOf() |
| 1538 | { |
| 1539 | SBValue sb_value; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1540 | ValueLocker locker; |
| 1541 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1542 | if (value_sp) |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1543 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1544 | Error error; |
| 1545 | sb_value.SetSP(value_sp->AddressOf (error),GetPreferDynamicValue(), GetPreferSyntheticValue()); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1546 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1547 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1548 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1549 | log->Printf ("SBValue(%p)::AddressOf () => SBValue(%p)", |
| 1550 | static_cast<void*>(value_sp.get()), |
| 1551 | static_cast<void*>(value_sp.get())); |
| 1552 | |
Enrico Granata | 6f3533f | 2011-07-29 19:53:35 +0000 | [diff] [blame] | 1553 | return sb_value; |
Johnny Chen | 4a871f9 | 2011-08-09 22:38:07 +0000 | [diff] [blame] | 1554 | } |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1555 | |
| 1556 | lldb::addr_t |
| 1557 | SBValue::GetLoadAddress() |
| 1558 | { |
| 1559 | lldb::addr_t value = LLDB_INVALID_ADDRESS; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1560 | ValueLocker locker; |
| 1561 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1562 | if (value_sp) |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1563 | { |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 1564 | TargetSP target_sp (value_sp->GetTargetSP()); |
| 1565 | if (target_sp) |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1566 | { |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1567 | const bool scalar_is_load_address = true; |
| 1568 | AddressType addr_type; |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1569 | value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1570 | if (addr_type == eAddressTypeFile) |
| 1571 | { |
Greg Clayton | e72dfb3 | 2012-02-24 01:59:29 +0000 | [diff] [blame] | 1572 | ModuleSP module_sp (value_sp->GetModule()); |
| 1573 | if (!module_sp) |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1574 | value = LLDB_INVALID_ADDRESS; |
| 1575 | else |
| 1576 | { |
| 1577 | Address addr; |
Greg Clayton | e72dfb3 | 2012-02-24 01:59:29 +0000 | [diff] [blame] | 1578 | module_sp->ResolveFileAddress(value, addr); |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 1579 | value = addr.GetLoadAddress(target_sp.get()); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1580 | } |
| 1581 | } |
| 1582 | else if (addr_type == eAddressTypeHost || addr_type == eAddressTypeInvalid) |
| 1583 | value = LLDB_INVALID_ADDRESS; |
| 1584 | } |
| 1585 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1586 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1587 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1588 | log->Printf ("SBValue(%p)::GetLoadAddress () => (%" PRIu64 ")", |
| 1589 | static_cast<void*>(value_sp.get()), value); |
| 1590 | |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1591 | return value; |
| 1592 | } |
| 1593 | |
| 1594 | lldb::SBAddress |
| 1595 | SBValue::GetAddress() |
| 1596 | { |
| 1597 | Address addr; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1598 | ValueLocker locker; |
| 1599 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1600 | if (value_sp) |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1601 | { |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 1602 | TargetSP target_sp (value_sp->GetTargetSP()); |
| 1603 | if (target_sp) |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1604 | { |
| 1605 | lldb::addr_t value = LLDB_INVALID_ADDRESS; |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1606 | const bool scalar_is_load_address = true; |
| 1607 | AddressType addr_type; |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1608 | value = value_sp->GetAddressOf(scalar_is_load_address, &addr_type); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1609 | if (addr_type == eAddressTypeFile) |
| 1610 | { |
Greg Clayton | e72dfb3 | 2012-02-24 01:59:29 +0000 | [diff] [blame] | 1611 | ModuleSP module_sp (value_sp->GetModule()); |
| 1612 | if (module_sp) |
| 1613 | module_sp->ResolveFileAddress(value, addr); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1614 | } |
| 1615 | else if (addr_type == eAddressTypeLoad) |
| 1616 | { |
| 1617 | // no need to check the return value on this.. if it can actually do the resolve |
| 1618 | // addr will be in the form (section,offset), otherwise it will simply be returned |
| 1619 | // as (NULL, value) |
Greg Clayton | cc4d014 | 2012-02-17 07:49:44 +0000 | [diff] [blame] | 1620 | addr.SetLoadAddress(value, target_sp.get()); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1621 | } |
| 1622 | } |
| 1623 | } |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1624 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1625 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1626 | log->Printf ("SBValue(%p)::GetAddress () => (%s,%" PRIu64 ")", |
| 1627 | static_cast<void*>(value_sp.get()), |
| 1628 | (addr.GetSection() |
| 1629 | ? addr.GetSection()->GetName().GetCString() |
| 1630 | : "NULL"), |
Jim Ingham | 35e1bda | 2012-10-16 21:41:58 +0000 | [diff] [blame] | 1631 | addr.GetOffset()); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1632 | return SBAddress(new Address(addr)); |
| 1633 | } |
| 1634 | |
| 1635 | lldb::SBData |
| 1636 | SBValue::GetPointeeData (uint32_t item_idx, |
| 1637 | uint32_t item_count) |
| 1638 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1639 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1640 | lldb::SBData sb_data; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1641 | ValueLocker locker; |
| 1642 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1643 | if (value_sp) |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1644 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1645 | TargetSP target_sp (value_sp->GetTargetSP()); |
| 1646 | if (target_sp) |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1647 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1648 | DataExtractorSP data_sp(new DataExtractor()); |
| 1649 | value_sp->GetPointeeData(*data_sp, item_idx, item_count); |
| 1650 | if (data_sp->GetByteSize() > 0) |
| 1651 | *sb_data = data_sp; |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1652 | } |
| 1653 | } |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1654 | if (log) |
| 1655 | log->Printf ("SBValue(%p)::GetPointeeData (%d, %d) => SBData(%p)", |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1656 | static_cast<void*>(value_sp.get()), item_idx, item_count, |
| 1657 | static_cast<void*>(sb_data.get())); |
| 1658 | |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1659 | return sb_data; |
| 1660 | } |
| 1661 | |
| 1662 | lldb::SBData |
| 1663 | SBValue::GetData () |
| 1664 | { |
Greg Clayton | 5160ce5 | 2013-03-27 23:08:40 +0000 | [diff] [blame] | 1665 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1666 | lldb::SBData sb_data; |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1667 | ValueLocker locker; |
| 1668 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1669 | if (value_sp) |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1670 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1671 | DataExtractorSP data_sp(new DataExtractor()); |
Sean Callanan | 866e91c | 2014-02-28 22:27:53 +0000 | [diff] [blame] | 1672 | Error error; |
| 1673 | value_sp->GetData(*data_sp, error); |
| 1674 | if (error.Success()) |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1675 | *sb_data = data_sp; |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1676 | } |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1677 | if (log) |
| 1678 | log->Printf ("SBValue(%p)::GetData () => SBData(%p)", |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1679 | static_cast<void*>(value_sp.get()), |
| 1680 | static_cast<void*>(sb_data.get())); |
| 1681 | |
Enrico Granata | 9128ee2 | 2011-09-06 19:20:51 +0000 | [diff] [blame] | 1682 | return sb_data; |
| 1683 | } |
Greg Clayton | 1b282f9 | 2011-10-13 18:08:26 +0000 | [diff] [blame] | 1684 | |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1685 | bool |
| 1686 | SBValue::SetData (lldb::SBData &data, SBError &error) |
| 1687 | { |
| 1688 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1689 | ValueLocker locker; |
| 1690 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1691 | bool ret = true; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1692 | |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1693 | if (value_sp) |
| 1694 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1695 | DataExtractor *data_extractor = data.get(); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1696 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1697 | if (!data_extractor) |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1698 | { |
| 1699 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1700 | log->Printf ("SBValue(%p)::SetData() => error: no data to set", |
| 1701 | static_cast<void*>(value_sp.get())); |
| 1702 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1703 | error.SetErrorString("No data to set"); |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1704 | ret = false; |
| 1705 | } |
| 1706 | else |
| 1707 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1708 | Error set_error; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1709 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1710 | value_sp->SetData(*data_extractor, set_error); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1711 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1712 | if (!set_error.Success()) |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1713 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1714 | error.SetErrorStringWithFormat("Couldn't set data: %s", set_error.AsCString()); |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1715 | ret = false; |
| 1716 | } |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1717 | } |
| 1718 | } |
| 1719 | else |
| 1720 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1721 | error.SetErrorStringWithFormat ("Couldn't set data: could not get SBValue: %s", locker.GetError().AsCString()); |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1722 | ret = false; |
| 1723 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1724 | |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1725 | if (log) |
| 1726 | log->Printf ("SBValue(%p)::SetData (%p) => %s", |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1727 | static_cast<void*>(value_sp.get()), |
| 1728 | static_cast<void*>(data.get()), ret ? "true" : "false"); |
Sean Callanan | 389823e | 2013-04-13 01:21:23 +0000 | [diff] [blame] | 1729 | return ret; |
| 1730 | } |
| 1731 | |
Enrico Granata | 10de090 | 2012-10-10 22:54:17 +0000 | [diff] [blame] | 1732 | lldb::SBDeclaration |
| 1733 | SBValue::GetDeclaration () |
| 1734 | { |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1735 | ValueLocker locker; |
| 1736 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Enrico Granata | 10de090 | 2012-10-10 22:54:17 +0000 | [diff] [blame] | 1737 | SBDeclaration decl_sb; |
| 1738 | if (value_sp) |
| 1739 | { |
| 1740 | Declaration decl; |
| 1741 | if (value_sp->GetDeclaration(decl)) |
| 1742 | decl_sb.SetDeclaration(decl); |
| 1743 | } |
| 1744 | return decl_sb; |
| 1745 | } |
| 1746 | |
Greg Clayton | 1b282f9 | 2011-10-13 18:08:26 +0000 | [diff] [blame] | 1747 | lldb::SBWatchpoint |
Johnny Chen | b90827e | 2012-06-04 23:19:54 +0000 | [diff] [blame] | 1748 | SBValue::Watch (bool resolve_location, bool read, bool write, SBError &error) |
Greg Clayton | 1b282f9 | 2011-10-13 18:08:26 +0000 | [diff] [blame] | 1749 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1750 | SBWatchpoint sb_watchpoint; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1751 | |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1752 | // If the SBValue is not valid, there's no point in even trying to watch it. |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1753 | ValueLocker locker; |
| 1754 | lldb::ValueObjectSP value_sp(GetSP(locker)); |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1755 | TargetSP target_sp (GetTarget().GetSP()); |
| 1756 | if (value_sp && target_sp) |
Greg Clayton | 1b282f9 | 2011-10-13 18:08:26 +0000 | [diff] [blame] | 1757 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1758 | // Read and Write cannot both be false. |
| 1759 | if (!read && !write) |
| 1760 | return sb_watchpoint; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1761 | |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1762 | // If the value is not in scope, don't try and watch and invalid value |
| 1763 | if (!IsInScope()) |
| 1764 | return sb_watchpoint; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1765 | |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1766 | addr_t addr = GetLoadAddress(); |
| 1767 | if (addr == LLDB_INVALID_ADDRESS) |
| 1768 | return sb_watchpoint; |
| 1769 | size_t byte_size = GetByteSize(); |
| 1770 | if (byte_size == 0) |
| 1771 | return sb_watchpoint; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1772 | |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1773 | uint32_t watch_type = 0; |
| 1774 | if (read) |
| 1775 | watch_type |= LLDB_WATCH_TYPE_READ; |
| 1776 | if (write) |
| 1777 | watch_type |= LLDB_WATCH_TYPE_WRITE; |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1778 | |
Johnny Chen | b90827e | 2012-06-04 23:19:54 +0000 | [diff] [blame] | 1779 | Error rc; |
Greg Clayton | 57ee306 | 2013-07-11 22:46:58 +0000 | [diff] [blame] | 1780 | ClangASTType type (value_sp->GetClangType()); |
Jim Ingham | a7dfb66 | 2012-10-23 07:20:06 +0000 | [diff] [blame] | 1781 | WatchpointSP watchpoint_sp = target_sp->CreateWatchpoint(addr, byte_size, &type, watch_type, rc); |
Johnny Chen | b90827e | 2012-06-04 23:19:54 +0000 | [diff] [blame] | 1782 | error.SetError(rc); |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1783 | |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 1784 | if (watchpoint_sp) |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1785 | { |
| 1786 | sb_watchpoint.SetSP (watchpoint_sp); |
| 1787 | Declaration decl; |
| 1788 | if (value_sp->GetDeclaration (decl)) |
| 1789 | { |
Daniel Malea | e0f8f57 | 2013-08-26 23:57:52 +0000 | [diff] [blame] | 1790 | if (decl.GetFile()) |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1791 | { |
| 1792 | StreamString ss; |
| 1793 | // True to show fullpath for declaration file. |
| 1794 | decl.DumpStopContext(&ss, true); |
| 1795 | watchpoint_sp->SetDeclInfo(ss.GetString()); |
| 1796 | } |
| 1797 | } |
| 1798 | } |
Greg Clayton | 1b282f9 | 2011-10-13 18:08:26 +0000 | [diff] [blame] | 1799 | } |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1800 | else if (target_sp) |
| 1801 | { |
| 1802 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
| 1803 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1804 | log->Printf ("SBValue(%p)::Watch() => error getting SBValue: %s", |
| 1805 | static_cast<void*>(value_sp.get()), |
| 1806 | locker.GetError().AsCString()); |
| 1807 | |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1808 | error.SetErrorStringWithFormat("could not get SBValue: %s", locker.GetError().AsCString()); |
| 1809 | } |
| 1810 | else |
| 1811 | { |
| 1812 | Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
| 1813 | if (log) |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1814 | log->Printf ("SBValue(%p)::Watch() => error getting SBValue: no target", |
| 1815 | static_cast<void*>(value_sp.get())); |
Jim Ingham | 362e39a | 2013-05-15 02:16:21 +0000 | [diff] [blame] | 1816 | error.SetErrorString("could not set watchpoint, a target is required"); |
| 1817 | } |
Saleem Abdulrasool | 324a103 | 2014-04-04 04:06:10 +0000 | [diff] [blame] | 1818 | |
Greg Clayton | 1b282f9 | 2011-10-13 18:08:26 +0000 | [diff] [blame] | 1819 | return sb_watchpoint; |
| 1820 | } |
| 1821 | |
Johnny Chen | d3761a7 | 2012-06-04 23:45:50 +0000 | [diff] [blame] | 1822 | // FIXME: Remove this method impl (as well as the decl in .h) once it is no longer needed. |
| 1823 | // Backward compatibility fix in the interim. |
| 1824 | lldb::SBWatchpoint |
| 1825 | SBValue::Watch (bool resolve_location, bool read, bool write) |
| 1826 | { |
Johnny Chen | 974759f | 2012-06-05 00:14:15 +0000 | [diff] [blame] | 1827 | SBError error; |
| 1828 | return Watch(resolve_location, read, write, error); |
Johnny Chen | d3761a7 | 2012-06-04 23:45:50 +0000 | [diff] [blame] | 1829 | } |
| 1830 | |
Greg Clayton | 1b282f9 | 2011-10-13 18:08:26 +0000 | [diff] [blame] | 1831 | lldb::SBWatchpoint |
Johnny Chen | b90827e | 2012-06-04 23:19:54 +0000 | [diff] [blame] | 1832 | SBValue::WatchPointee (bool resolve_location, bool read, bool write, SBError &error) |
Greg Clayton | 1b282f9 | 2011-10-13 18:08:26 +0000 | [diff] [blame] | 1833 | { |
Greg Clayton | 81e871e | 2012-02-04 02:27:34 +0000 | [diff] [blame] | 1834 | SBWatchpoint sb_watchpoint; |
| 1835 | if (IsInScope() && GetType().IsPointerType()) |
Johnny Chen | b90827e | 2012-06-04 23:19:54 +0000 | [diff] [blame] | 1836 | sb_watchpoint = Dereference().Watch (resolve_location, read, write, error); |
Greg Clayton | 1b282f9 | 2011-10-13 18:08:26 +0000 | [diff] [blame] | 1837 | return sb_watchpoint; |
| 1838 | } |