1 //===-- SBExpressionOptions.cpp ---------------------------------------------*- 2 //C++ -*-===// 3 // 4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5 // See https://llvm.org/LICENSE.txt for license information. 6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/API/SBExpressionOptions.h" 11 #include "SBReproducerPrivate.h" 12 #include "Utils.h" 13 #include "lldb/API/SBStream.h" 14 #include "lldb/Target/Target.h" 15 16 using namespace lldb; 17 using namespace lldb_private; 18 19 SBExpressionOptions::SBExpressionOptions() 20 : m_opaque_up(new EvaluateExpressionOptions()) { 21 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBExpressionOptions); 22 } 23 24 SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) 25 : m_opaque_up() { 26 LLDB_RECORD_CONSTRUCTOR(SBExpressionOptions, 27 (const lldb::SBExpressionOptions &), rhs); 28 29 m_opaque_up = clone(rhs.m_opaque_up); 30 } 31 32 const SBExpressionOptions &SBExpressionOptions:: 33 operator=(const SBExpressionOptions &rhs) { 34 LLDB_RECORD_METHOD( 35 const lldb::SBExpressionOptions &, 36 SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &), rhs); 37 38 if (this != &rhs) 39 m_opaque_up = clone(rhs.m_opaque_up); 40 return LLDB_RECORD_RESULT(*this); 41 } 42 43 SBExpressionOptions::~SBExpressionOptions() {} 44 45 bool SBExpressionOptions::GetCoerceResultToId() const { 46 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, 47 GetCoerceResultToId); 48 49 return m_opaque_up->DoesCoerceToId(); 50 } 51 52 void SBExpressionOptions::SetCoerceResultToId(bool coerce) { 53 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetCoerceResultToId, (bool), 54 coerce); 55 56 m_opaque_up->SetCoerceToId(coerce); 57 } 58 59 bool SBExpressionOptions::GetUnwindOnError() const { 60 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetUnwindOnError); 61 62 return m_opaque_up->DoesUnwindOnError(); 63 } 64 65 void SBExpressionOptions::SetUnwindOnError(bool unwind) { 66 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool), 67 unwind); 68 69 m_opaque_up->SetUnwindOnError(unwind); 70 } 71 72 bool SBExpressionOptions::GetIgnoreBreakpoints() const { 73 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, 74 GetIgnoreBreakpoints); 75 76 return m_opaque_up->DoesIgnoreBreakpoints(); 77 } 78 79 void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) { 80 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, (bool), 81 ignore); 82 83 m_opaque_up->SetIgnoreBreakpoints(ignore); 84 } 85 86 lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const { 87 LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::DynamicValueType, SBExpressionOptions, 88 GetFetchDynamicValue); 89 90 return m_opaque_up->GetUseDynamic(); 91 } 92 93 void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) { 94 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetFetchDynamicValue, 95 (lldb::DynamicValueType), dynamic); 96 97 m_opaque_up->SetUseDynamic(dynamic); 98 } 99 100 uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const { 101 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions, 102 GetTimeoutInMicroSeconds); 103 104 return m_opaque_up->GetTimeout() ? m_opaque_up->GetTimeout()->count() : 0; 105 } 106 107 void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) { 108 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds, 109 (uint32_t), timeout); 110 111 m_opaque_up->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None) 112 : std::chrono::microseconds(timeout)); 113 } 114 115 uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const { 116 LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBExpressionOptions, 117 GetOneThreadTimeoutInMicroSeconds); 118 119 return m_opaque_up->GetOneThreadTimeout() 120 ? m_opaque_up->GetOneThreadTimeout()->count() 121 : 0; 122 } 123 124 void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) { 125 LLDB_RECORD_METHOD(void, SBExpressionOptions, 126 SetOneThreadTimeoutInMicroSeconds, (uint32_t), timeout); 127 128 m_opaque_up->SetOneThreadTimeout(timeout == 0 129 ? Timeout<std::micro>(llvm::None) 130 : std::chrono::microseconds(timeout)); 131 } 132 133 bool SBExpressionOptions::GetTryAllThreads() const { 134 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetTryAllThreads); 135 136 return m_opaque_up->GetTryAllThreads(); 137 } 138 139 void SBExpressionOptions::SetTryAllThreads(bool run_others) { 140 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool), 141 run_others); 142 143 m_opaque_up->SetTryAllThreads(run_others); 144 } 145 146 bool SBExpressionOptions::GetStopOthers() const { 147 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, GetStopOthers); 148 149 return m_opaque_up->GetStopOthers(); 150 } 151 152 void SBExpressionOptions::SetStopOthers(bool run_others) { 153 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetStopOthers, (bool), 154 run_others); 155 156 m_opaque_up->SetStopOthers(run_others); 157 } 158 159 bool SBExpressionOptions::GetTrapExceptions() const { 160 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBExpressionOptions, 161 GetTrapExceptions); 162 163 return m_opaque_up->GetTrapExceptions(); 164 } 165 166 void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) { 167 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool), 168 trap_exceptions); 169 170 m_opaque_up->SetTrapExceptions(trap_exceptions); 171 } 172 173 void SBExpressionOptions::SetLanguage(lldb::LanguageType language) { 174 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetLanguage, 175 (lldb::LanguageType), language); 176 177 m_opaque_up->SetLanguage(language); 178 } 179 180 void SBExpressionOptions::SetCancelCallback( 181 lldb::ExpressionCancelCallback callback, void *baton) { 182 LLDB_RECORD_DUMMY(void, SBExpressionOptions, SetCancelCallback, 183 (lldb::ExpressionCancelCallback, void *), callback, baton); 184 185 m_opaque_up->SetCancelCallback(callback, baton); 186 } 187 188 bool SBExpressionOptions::GetGenerateDebugInfo() { 189 LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetGenerateDebugInfo); 190 191 return m_opaque_up->GetGenerateDebugInfo(); 192 } 193 194 void SBExpressionOptions::SetGenerateDebugInfo(bool b) { 195 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, (bool), 196 b); 197 198 return m_opaque_up->SetGenerateDebugInfo(b); 199 } 200 201 bool SBExpressionOptions::GetSuppressPersistentResult() { 202 LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, 203 GetSuppressPersistentResult); 204 205 return m_opaque_up->GetResultIsInternal(); 206 } 207 208 void SBExpressionOptions::SetSuppressPersistentResult(bool b) { 209 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult, 210 (bool), b); 211 212 return m_opaque_up->SetResultIsInternal(b); 213 } 214 215 const char *SBExpressionOptions::GetPrefix() const { 216 LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBExpressionOptions, 217 GetPrefix); 218 219 return m_opaque_up->GetPrefix(); 220 } 221 222 void SBExpressionOptions::SetPrefix(const char *prefix) { 223 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetPrefix, (const char *), 224 prefix); 225 226 return m_opaque_up->SetPrefix(prefix); 227 } 228 229 bool SBExpressionOptions::GetAutoApplyFixIts() { 230 LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAutoApplyFixIts); 231 232 return m_opaque_up->GetAutoApplyFixIts(); 233 } 234 235 void SBExpressionOptions::SetAutoApplyFixIts(bool b) { 236 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool), b); 237 238 return m_opaque_up->SetAutoApplyFixIts(b); 239 } 240 241 bool SBExpressionOptions::GetTopLevel() { 242 LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetTopLevel); 243 244 return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel; 245 } 246 247 void SBExpressionOptions::SetTopLevel(bool b) { 248 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetTopLevel, (bool), b); 249 250 m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel 251 : m_opaque_up->default_execution_policy); 252 } 253 254 bool SBExpressionOptions::GetAllowJIT() { 255 LLDB_RECORD_METHOD_NO_ARGS(bool, SBExpressionOptions, GetAllowJIT); 256 257 return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever; 258 } 259 260 void SBExpressionOptions::SetAllowJIT(bool allow) { 261 LLDB_RECORD_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool), allow); 262 263 m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy 264 : eExecutionPolicyNever); 265 } 266 267 EvaluateExpressionOptions *SBExpressionOptions::get() const { 268 return m_opaque_up.get(); 269 } 270 271 EvaluateExpressionOptions &SBExpressionOptions::ref() const { 272 return *(m_opaque_up.get()); 273 } 274 275 namespace lldb_private { 276 namespace repro { 277 278 template <> 279 void RegisterMethods<SBExpressionOptions>(Registry &R) { 280 LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, ()); 281 LLDB_REGISTER_CONSTRUCTOR(SBExpressionOptions, 282 (const lldb::SBExpressionOptions &)); 283 LLDB_REGISTER_METHOD( 284 const lldb::SBExpressionOptions &, 285 SBExpressionOptions, operator=,(const lldb::SBExpressionOptions &)); 286 LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetCoerceResultToId, 287 ()); 288 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetCoerceResultToId, 289 (bool)); 290 LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetUnwindOnError, ()); 291 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetUnwindOnError, (bool)); 292 LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetIgnoreBreakpoints, 293 ()); 294 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetIgnoreBreakpoints, 295 (bool)); 296 LLDB_REGISTER_METHOD_CONST(lldb::DynamicValueType, SBExpressionOptions, 297 GetFetchDynamicValue, ()); 298 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetFetchDynamicValue, 299 (lldb::DynamicValueType)); 300 LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions, 301 GetTimeoutInMicroSeconds, ()); 302 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTimeoutInMicroSeconds, 303 (uint32_t)); 304 LLDB_REGISTER_METHOD_CONST(uint32_t, SBExpressionOptions, 305 GetOneThreadTimeoutInMicroSeconds, ()); 306 LLDB_REGISTER_METHOD(void, SBExpressionOptions, 307 SetOneThreadTimeoutInMicroSeconds, (uint32_t)); 308 LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTryAllThreads, ()); 309 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTryAllThreads, (bool)); 310 LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetStopOthers, ()); 311 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetStopOthers, (bool)); 312 LLDB_REGISTER_METHOD_CONST(bool, SBExpressionOptions, GetTrapExceptions, 313 ()); 314 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTrapExceptions, (bool)); 315 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetLanguage, 316 (lldb::LanguageType)); 317 LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetGenerateDebugInfo, ()); 318 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetGenerateDebugInfo, 319 (bool)); 320 LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetSuppressPersistentResult, 321 ()); 322 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetSuppressPersistentResult, 323 (bool)); 324 LLDB_REGISTER_METHOD_CONST(const char *, SBExpressionOptions, GetPrefix, 325 ()); 326 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetPrefix, (const char *)); 327 LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAutoApplyFixIts, ()); 328 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAutoApplyFixIts, (bool)); 329 LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetTopLevel, ()); 330 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetTopLevel, (bool)); 331 LLDB_REGISTER_METHOD(bool, SBExpressionOptions, GetAllowJIT, ()); 332 LLDB_REGISTER_METHOD(void, SBExpressionOptions, SetAllowJIT, (bool)); 333 } 334 335 } 336 } 337