llvm-project/lldb/source/API/SBExpressionOptions.cpp

177 lines
5.1 KiB
C++
Raw Normal View History

//===-- SBExpressionOptions.cpp ---------------------------------------------*-
//C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "lldb/API/SBExpressionOptions.h"
#include "lldb/API/SBStream.h"
#include "lldb/Target/Target.h"
using namespace lldb;
using namespace lldb_private;
SBExpressionOptions::SBExpressionOptions()
: m_opaque_ap(new EvaluateExpressionOptions()) {}
SBExpressionOptions::SBExpressionOptions(const SBExpressionOptions &rhs) {
m_opaque_ap.reset(new EvaluateExpressionOptions());
*(m_opaque_ap.get()) = rhs.ref();
}
const SBExpressionOptions &SBExpressionOptions::
operator=(const SBExpressionOptions &rhs) {
if (this != &rhs) {
this->ref() = rhs.ref();
}
return *this;
}
SBExpressionOptions::~SBExpressionOptions() {}
bool SBExpressionOptions::GetCoerceResultToId() const {
return m_opaque_ap->DoesCoerceToId();
}
void SBExpressionOptions::SetCoerceResultToId(bool coerce) {
m_opaque_ap->SetCoerceToId(coerce);
}
bool SBExpressionOptions::GetUnwindOnError() const {
return m_opaque_ap->DoesUnwindOnError();
}
void SBExpressionOptions::SetUnwindOnError(bool unwind) {
m_opaque_ap->SetUnwindOnError(unwind);
}
bool SBExpressionOptions::GetIgnoreBreakpoints() const {
return m_opaque_ap->DoesIgnoreBreakpoints();
}
void SBExpressionOptions::SetIgnoreBreakpoints(bool ignore) {
m_opaque_ap->SetIgnoreBreakpoints(ignore);
}
lldb::DynamicValueType SBExpressionOptions::GetFetchDynamicValue() const {
return m_opaque_ap->GetUseDynamic();
}
void SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType dynamic) {
m_opaque_ap->SetUseDynamic(dynamic);
}
uint32_t SBExpressionOptions::GetTimeoutInMicroSeconds() const {
return m_opaque_ap->GetTimeout() ? m_opaque_ap->GetTimeout()->count() : 0;
}
void SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t timeout) {
m_opaque_ap->SetTimeout(timeout == 0 ? Timeout<std::micro>(llvm::None)
: std::chrono::microseconds(timeout));
}
uint32_t SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds() const {
return m_opaque_ap->GetOneThreadTimeout() ? m_opaque_ap->GetOneThreadTimeout()->count() : 0;
}
void SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t timeout) {
m_opaque_ap->SetOneThreadTimeout(timeout == 0
? Timeout<std::micro>(llvm::None)
: std::chrono::microseconds(timeout));
}
bool SBExpressionOptions::GetTryAllThreads() const {
return m_opaque_ap->GetTryAllThreads();
}
void SBExpressionOptions::SetTryAllThreads(bool run_others) {
m_opaque_ap->SetTryAllThreads(run_others);
}
bool SBExpressionOptions::GetStopOthers() const {
return m_opaque_ap->GetStopOthers();
}
void SBExpressionOptions::SetStopOthers(bool run_others) {
m_opaque_ap->SetStopOthers(run_others);
}
bool SBExpressionOptions::GetTrapExceptions() const {
return m_opaque_ap->GetTrapExceptions();
}
void SBExpressionOptions::SetTrapExceptions(bool trap_exceptions) {
m_opaque_ap->SetTrapExceptions(trap_exceptions);
}
void SBExpressionOptions::SetLanguage(lldb::LanguageType language) {
m_opaque_ap->SetLanguage(language);
Initial merge of some of the iOS 8 / Mac OS X Yosemite specific lldb support. I'll be doing more testing & cleanup but I wanted to get the initial checkin done. This adds a new SBExpressionOptions::SetLanguage API for selecting a language of an expression. I added adds a new SBThread::GetInfoItemByPathString for retriving information about a thread from that thread's StructuredData. I added a new StructuredData class for representing key-value/array/dictionary information (e.g. JSON formatted data). Helper functions to read JSON and create a StructuredData object, and to print a StructuredData object in JSON format are included. A few Cocoa / Cocoa Touch data formatters were updated by Enrico to track changes in iOS 8 / Yosemite. Before we query a thread's extended information, the system runtime may provide hints to the remote debug stub that it will use to retrieve values out of runtime structures. I added a new SystemRuntime method AddThreadExtendedInfoPacketHints which allows the SystemRuntime to add key-value type data to the initial request that we send to the remote stub. The thread-format formatter string can now retrieve values out of a thread's extended info structured data. The default thread-format string picks up two of these - thread.info.activity.name and thread.info.trace_messages. I added a new "jThreadExtendedInfo" packet in debugserver; I will add documentation to the lldb-gdb-remote.txt doc soon. It accepts JSON formatted arguments (most importantly, "thread":threadnum) and it returns a variety of information regarding the thread to lldb in JSON format. This JSON return is scanned into a StructuredData object that is associated with the thread; UI layers can query the thread's StructuredData to see if key-values are present, and if so, show them to the user. These key-values are likely to be specific to different targets with some commonality among many targets. For instance, many targets will be able to advertise the pthread_t value for a thread. I added an initial rough cut of "thread info" command which will print the information about a thread from the jThreadExtendedInfo result. I need to do more work to make this format reasonably. Han Ming added calls into the pmenergy and pmsample libraries if debugserver is run on Mac OS X Yosemite to get information about the inferior's power use. I added support to debugserver for gathering the Genealogy information about threads, if it exists, and returning it in the jThreadExtendedInfo JSON result. llvm-svn: 210874
2014-06-13 10:37:02 +08:00
}
void SBExpressionOptions::SetCancelCallback(
lldb::ExpressionCancelCallback callback, void *baton) {
m_opaque_ap->SetCancelCallback(callback, baton);
}
bool SBExpressionOptions::GetGenerateDebugInfo() {
return m_opaque_ap->GetGenerateDebugInfo();
}
void SBExpressionOptions::SetGenerateDebugInfo(bool b) {
return m_opaque_ap->SetGenerateDebugInfo(b);
}
bool SBExpressionOptions::GetSuppressPersistentResult() {
return m_opaque_ap->GetResultIsInternal();
}
void SBExpressionOptions::SetSuppressPersistentResult(bool b) {
return m_opaque_ap->SetResultIsInternal(b);
}
const char *SBExpressionOptions::GetPrefix() const {
return m_opaque_ap->GetPrefix();
2015-05-28 06:32:39 +08:00
}
void SBExpressionOptions::SetPrefix(const char *prefix) {
return m_opaque_ap->SetPrefix(prefix);
2015-05-28 06:32:39 +08:00
}
bool SBExpressionOptions::GetAutoApplyFixIts() {
return m_opaque_ap->GetAutoApplyFixIts();
}
void SBExpressionOptions::SetAutoApplyFixIts(bool b) {
return m_opaque_ap->SetAutoApplyFixIts(b);
}
bool SBExpressionOptions::GetTopLevel() {
return m_opaque_ap->GetExecutionPolicy() == eExecutionPolicyTopLevel;
}
void SBExpressionOptions::SetTopLevel(bool b) {
m_opaque_ap->SetExecutionPolicy(b ? eExecutionPolicyTopLevel
: m_opaque_ap->default_execution_policy);
}
bool SBExpressionOptions::GetAllowJIT() {
return m_opaque_ap->GetExecutionPolicy() != eExecutionPolicyNever;
}
void SBExpressionOptions::SetAllowJIT(bool allow) {
m_opaque_ap->SetExecutionPolicy(allow ? m_opaque_ap->default_execution_policy
: eExecutionPolicyNever);
}
EvaluateExpressionOptions *SBExpressionOptions::get() const {
return m_opaque_ap.get();
}
EvaluateExpressionOptions &SBExpressionOptions::ref() const {
return *(m_opaque_ap.get());
}