1 //===-- SBExpressionOptions.cpp -------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "lldb/API/SBExpressionOptions.h" 10 #include "Utils.h" 11 #include "lldb/API/SBStream.h" 12 #include "lldb/Target/Target.h" 13 #include "lldb/Utility/Instrumentation.h" 14 15 using namespace lldb; 16 using namespace lldb_private; 17 18 SBExpressionOptions::SBExpressionOptions() 19 : m_opaque_up(new EvaluateExpressionOptions()) { 20 LLDB_INSTRUMENT_VA(this); 21 } 22 23 SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) { 24 LLDB_INSTRUMENT_VA(this, rhs); 25 26 m_opaque_up = clone(rhs.m_opaque_up); 27 } 28 29 const SBExpressionOptions &SBExpressionOptions:: 30 operator=(const SBExpressionOptions &rhs) { 31 LLDB_INSTRUMENT_VA(this, rhs); 32 33 if (this != &rhs) 34 m_opaque_up = clone(rhs.m_opaque_up); 35 return *this; 36 } 37 38 SBExpressionOptions::~SBExpressionOptions() = default; 39 40 bool SBExpressionOptions::GetCoerceResultToId() const { 41 LLDB_INSTRUMENT_VA(this); 42 43 return m_opaque_up->DoesCoerceToId(); 44 } 45 46 void SBExpressionOptions::SetCoerceResultToId(bool coerce) { 47 LLDB_INSTRUMENT_VA(this, coerce); 48 49 m_opaque_up->SetCoerceToId(coerce); 50 } 51 52 bool SBExpressionOptions::GetUnwindOnError() const { 53 LLDB_INSTRUMENT_VA(this); 54 55 return m_opaque_up->DoesUnwindOnError(); 56 } 57 58 void SBExpressionOptions::SetUnwindOnError(bool unwind) { 59 LLDB_INSTRUMENT_VA(this, unwind); 60 61 m_opaque_up->SetUnwindOnError(unwind); 62 } 63 64 bool SBExpressionOptions::GetIgnoreBreakpoints() const { 65 LLDB_INSTRUMENT_VA(this); 66 67 return m_opaque_up->DoesIgnoreBreakpoints(); 68 } 69 70 void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) { 71 LLDB_INSTRUMENT_VA(this, ignore); 72 73 m_opaque_up->SetIgnoreBreakpoints(ignore); 74 } 75 76 lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const { 77 LLDB_INSTRUMENT_VA(this); 78 79 return m_opaque_up->GetUseDynamic(); 80 } 81 82 void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) { 83 LLDB_INSTRUMENT_VA(this, dynamic); 84 85 m_opaque_up->SetUseDynamic(dynamic); 86 } 87 88 uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const { 89 LLDB_INSTRUMENT_VA(this); 90 91 return m_opaque_up->GetTimeout() ? m_opaque_up->GetTimeout()->count() : 0; 92 } 93 94 void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) { 95 LLDB_INSTRUMENT_VA(this, timeout); 96 97 m_opaque_up->SetTimeout(timeout == 0 ? Timeout<std::micro>(std::nullopt) 98 : std::chrono::microseconds(timeout)); 99 } 100 101 uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const { 102 LLDB_INSTRUMENT_VA(this); 103 104 return m_opaque_up->GetOneThreadTimeout() 105 ? m_opaque_up->GetOneThreadTimeout()->count() 106 : 0; 107 } 108 109 void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) { 110 LLDB_INSTRUMENT_VA(this, timeout); 111 112 m_opaque_up->SetOneThreadTimeout(timeout == 0 113 ? Timeout<std::micro>(std::nullopt) 114 : std::chrono::microseconds(timeout)); 115 } 116 117 bool SBExpressionOptions::GetTryAllThreads() const { 118 LLDB_INSTRUMENT_VA(this); 119 120 return m_opaque_up->GetTryAllThreads(); 121 } 122 123 void SBExpressionOptions::SetTryAllThreads(bool run_others) { 124 LLDB_INSTRUMENT_VA(this, run_others); 125 126 m_opaque_up->SetTryAllThreads(run_others); 127 } 128 129 bool SBExpressionOptions::GetStopOthers() const { 130 LLDB_INSTRUMENT_VA(this); 131 132 return m_opaque_up->GetStopOthers(); 133 } 134 135 void SBExpressionOptions::SetStopOthers(bool run_others) { 136 LLDB_INSTRUMENT_VA(this, run_others); 137 138 m_opaque_up->SetStopOthers(run_others); 139 } 140 141 bool SBExpressionOptions::GetTrapExceptions() const { 142 LLDB_INSTRUMENT_VA(this); 143 144 return m_opaque_up->GetTrapExceptions(); 145 } 146 147 void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) { 148 LLDB_INSTRUMENT_VA(this, trap_exceptions); 149 150 m_opaque_up->SetTrapExceptions(trap_exceptions); 151 } 152 153 void SBExpressionOptions::SetLanguage(lldb::LanguageType language) { 154 LLDB_INSTRUMENT_VA(this, language); 155 156 m_opaque_up->SetLanguage(language); 157 } 158 159 void SBExpressionOptions::SetCancelCallback( 160 lldb::ExpressionCancelCallback callback, void *baton) { 161 LLDB_INSTRUMENT_VA(this, callback, baton); 162 163 m_opaque_up->SetCancelCallback(callback, baton); 164 } 165 166 bool SBExpressionOptions::GetGenerateDebugInfo() { 167 LLDB_INSTRUMENT_VA(this); 168 169 return m_opaque_up->GetGenerateDebugInfo(); 170 } 171 172 void SBExpressionOptions::SetGenerateDebugInfo(bool b) { 173 LLDB_INSTRUMENT_VA(this, b); 174 175 return m_opaque_up->SetGenerateDebugInfo(b); 176 } 177 178 bool SBExpressionOptions::GetSuppressPersistentResult() { 179 LLDB_INSTRUMENT_VA(this); 180 181 return m_opaque_up->GetSuppressPersistentResult(); 182 } 183 184 void SBExpressionOptions::SetSuppressPersistentResult(bool b) { 185 LLDB_INSTRUMENT_VA(this, b); 186 187 return m_opaque_up->SetSuppressPersistentResult(b); 188 } 189 190 const char *SBExpressionOptions::GetPrefix() const { 191 LLDB_INSTRUMENT_VA(this); 192 193 return ConstString(m_opaque_up->GetPrefix()).GetCString(); 194 } 195 196 void SBExpressionOptions::SetPrefix(const char *prefix) { 197 LLDB_INSTRUMENT_VA(this, prefix); 198 199 return m_opaque_up->SetPrefix(prefix); 200 } 201 202 bool SBExpressionOptions::GetAutoApplyFixIts() { 203 LLDB_INSTRUMENT_VA(this); 204 205 return m_opaque_up->GetAutoApplyFixIts(); 206 } 207 208 void SBExpressionOptions::SetAutoApplyFixIts(bool b) { 209 LLDB_INSTRUMENT_VA(this, b); 210 211 return m_opaque_up->SetAutoApplyFixIts(b); 212 } 213 214 uint64_t SBExpressionOptions::GetRetriesWithFixIts() { 215 LLDB_INSTRUMENT_VA(this); 216 217 return m_opaque_up->GetRetriesWithFixIts(); 218 } 219 220 void SBExpressionOptions::SetRetriesWithFixIts(uint64_t retries) { 221 LLDB_INSTRUMENT_VA(this, retries); 222 223 return m_opaque_up->SetRetriesWithFixIts(retries); 224 } 225 226 bool SBExpressionOptions::GetTopLevel() { 227 LLDB_INSTRUMENT_VA(this); 228 229 return m_opaque_up->GetExecutionPolicy() == eExecutionPolicyTopLevel; 230 } 231 232 void SBExpressionOptions::SetTopLevel(bool b) { 233 LLDB_INSTRUMENT_VA(this, b); 234 235 m_opaque_up->SetExecutionPolicy(b ? eExecutionPolicyTopLevel 236 : m_opaque_up->default_execution_policy); 237 } 238 239 bool SBExpressionOptions::GetAllowJIT() { 240 LLDB_INSTRUMENT_VA(this); 241 242 return m_opaque_up->GetExecutionPolicy() != eExecutionPolicyNever; 243 } 244 245 void SBExpressionOptions::SetAllowJIT(bool allow) { 246 LLDB_INSTRUMENT_VA(this, allow); 247 248 m_opaque_up->SetExecutionPolicy(allow ? m_opaque_up->default_execution_policy 249 : eExecutionPolicyNever); 250 } 251 252 EvaluateExpressionOptions *SBExpressionOptions::get() const { 253 return m_opaque_up.get(); 254 } 255 256 EvaluateExpressionOptions &SBExpressionOptions::ref() const { 257 return *m_opaque_up; 258 } 259