maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Fix Clang-tidy modernize-use-override warnings in source/Target; other minor fixes. 

llvm-svn: 251134
This commit is contained in:
Eugene Zelenko 2015-10-23 18:39:37 +00:00
parent 94660b3c36
commit 8f30a65ca3
5 changed files with 163 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
lldb/source/Target/LanguageRuntime.cpp
View File

@ -1,4 +1,4 @@
//===-- LanguageRuntime.cpp -------------------------------------------------*- C++ -*-===//
//===-- LanguageRuntime.cpp -------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -7,6 +7,10 @@
//
//===----------------------------------------------------------------------===//
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Target/LanguageRuntime.h"
#include "lldb/Target/ObjCLanguageRuntime.h"
#include "lldb/Target/Target.h"
@ -17,7 +21,6 @@
using namespace lldb;
using namespace lldb_private;
class ExceptionSearchFilter : public SearchFilter
{
public:
@ -33,8 +36,7 @@ public:
UpdateModuleListIfNeeded ();
}
virtual
~ExceptionSearchFilter() {}
~ExceptionSearchFilter() override = default;
bool
ModulePasses (const lldb::ModuleSP &module_sp) override
@ -52,7 +54,6 @@ public:
if (m_filter_sp)
return m_filter_sp->ModulePasses (spec);
return false;
}
void
@ -133,11 +134,8 @@ public:
{
}
virtual
~ExceptionBreakpointResolver()
{
}
~ExceptionBreakpointResolver() override = default;
Searcher::CallbackReturn
SearchCallback (SearchFilter &filter,
SymbolContext &context,
@ -187,6 +185,7 @@ public:
static inline bool classof(const BreakpointResolver *V) {
return V->getResolverID() == BreakpointResolver::ExceptionResolver;
}
protected:
BreakpointResolverSP
CopyForBreakpoint (Breakpoint &breakpoint) override
@ -244,7 +243,6 @@ protected:
bool m_throw_bp;
};
LanguageRuntime*
LanguageRuntime::FindPlugin (Process *process, lldb::LanguageType language)
{
@ -264,20 +262,12 @@ LanguageRuntime::FindPlugin (Process *process, lldb::LanguageType language)
return NULL;
}
//----------------------------------------------------------------------
// Constructor
//----------------------------------------------------------------------
LanguageRuntime::LanguageRuntime(Process *process) :
m_process (process)
{
}
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
LanguageRuntime::~LanguageRuntime()
{
}
LanguageRuntime::~LanguageRuntime() = default;
Breakpoint::BreakpointPreconditionSP
LanguageRuntime::CreateExceptionPrecondition (lldb::LanguageType language,

85
lldb/source/Target/Process.cpp
View File

@ -7,6 +7,10 @@
//
//===----------------------------------------------------------------------===//
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Target/Process.h"
#include "lldb/Breakpoint/StoppointCallbackContext.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
@ -58,7 +62,6 @@
using namespace lldb;
using namespace lldb_private;
// Comment out line below to disable memory caching, overriding the process setting
// target.process.disable-memory-cache
#define ENABLE_MEMORY_CACHING
@ -85,8 +88,8 @@ public:
{
}
virtual const Property *
GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
const Property *
GetPropertyAtIndex(const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const override
{
// When getting the value for a key from the process options, we will always
// try and grab the setting from the current process if there is one. Else we just
@ -154,9 +157,7 @@ ProcessProperties::ProcessProperties (lldb_private::Process *process) :
}
}
ProcessProperties::~ProcessProperties()
{
}
ProcessProperties::~ProcessProperties() = default;
void
ProcessProperties::OptionValueChangedCallback (void *baton, OptionValue *option_value)
@ -210,7 +211,6 @@ ProcessProperties::SetPythonOSPluginPath (const FileSpec &file)
m_collection_sp->SetPropertyAtIndexAsFileSpec(NULL, idx, file);
}
bool
ProcessProperties::GetIgnoreBreakpointsInExpressions () const
{
@ -564,8 +564,6 @@ ProcessLaunchCommandOptions::g_option_table[] =
{ 0 , false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
};
bool
ProcessInstanceInfoMatch::NameMatches (const char *process_name) const
{
@ -645,7 +643,6 @@ ProcessInstanceInfoMatch::MatchAllProcesses () const
return false;
return true;
}
void
@ -708,9 +705,6 @@ Process::GetStaticBroadcasterClass ()
return class_name;
}
//----------------------------------------------------------------------
// Process constructor
//----------------------------------------------------------------------
Process::Process(lldb::TargetSP target_sp, Listener &listener) :
Process(target_sp, listener, UnixSignals::Create(HostInfo::GetArchitecture()))
{
@ -822,9 +816,6 @@ Process::Process(lldb::TargetSP target_sp, Listener &listener, const UnixSignals
value_sp->SetUInt64Value(platform_cache_line_size);
}
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
Process::~Process()
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
@ -1274,14 +1265,10 @@ Process::HandleProcessStateChangedEvent (const EventSP &event_sp,
return true;
}
StateType
Process::WaitForState
(
const TimeValue *timeout,
const StateType *match_states,
const uint32_t num_match_states
)
Process::WaitForState(const TimeValue *timeout,
const StateType *match_states,
const uint32_t num_match_states)
{
EventSP event_sp;
uint32_t i;
@ -1456,7 +1443,6 @@ Process::GetExitStatus ()
return -1;
}
const char *
Process::GetExitDescription ()
{
@ -1556,7 +1542,6 @@ Process::SetProcessExitStatus (void *callback_baton,
return false;
}
void
Process::UpdateThreadListIfNeeded ()
{
@ -1670,15 +1655,7 @@ Process::GetNextThreadIndexID (uint64_t thread_id)
bool
Process::HasAssignedIndexIDToThread(uint64_t thread_id)
{
std::map<uint64_t, uint32_t>::iterator iterator = m_thread_id_to_index_id_map.find(thread_id);
if (iterator == m_thread_id_to_index_id_map.end())
{
return false;
}
else
{
return true;
}
return (m_thread_id_to_index_id_map.find(thread_id) != m_thread_id_to_index_id_map.end());
}
uint32_t
@ -2192,7 +2169,6 @@ Process::GetBreakpointSiteList() const
return m_breakpoint_site_list;
}
void
Process::DisableAllBreakpointSites ()
{
@ -2349,7 +2325,6 @@ Process::CreateBreakpointSite (const BreakpointLocationSP &owner, bool use_hardw
}
// We failed to enable the breakpoint
return LLDB_INVALID_BREAK_ID;
}
void
@ -2365,7 +2340,6 @@ Process::RemoveOwnerFromBreakpointSite (lldb::user_id_t owner_id, lldb::user_id_
}
}
size_t
Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t *buf) const
{
@ -2394,8 +2368,6 @@ Process::RemoveBreakpointOpcodesFromBuffer (addr_t bp_addr, size_t size, uint8_t
return bytes_removed;
}
size_t
Process::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site)
{
@ -2575,7 +2547,6 @@ Process::DisableSoftwareBreakpoint (BreakpointSite *bp_site)
(uint64_t)bp_addr,
error.AsCString());
return error;
}
// Uncomment to verify memory caching works after making changes to caching code
@ -2647,7 +2618,6 @@ Process::ReadCStringFromMemory (addr_t addr, std::string &out_str, Error &error)
return out_str.size();
}
size_t
Process::ReadStringFromMemory (addr_t addr, char *dst, size_t max_bytes, Error &error,
size_t type_width)
@ -2797,7 +2767,6 @@ Process::ReadPointerFromMemory (lldb::addr_t vm_addr, Error &error)
return LLDB_INVALID_ADDRESS;
}
bool
Process::WritePointerToMemory (lldb::addr_t vm_addr,
lldb::addr_t ptr_value,
@ -3068,7 +3037,6 @@ Process::DeallocateMemory (addr_t ptr)
return error;
}
ModuleSP
Process::ReadModuleFromMemory (const FileSpec& file_spec,
lldb::addr_t header_addr,
@ -3245,7 +3213,6 @@ Process::Launch (ProcessLaunchInfo &launch_info)
}
else if (state == eStateStopped || state == eStateCrashed)
{
DidLaunch ();
DynamicLoader *dyld = GetDynamicLoader ();
@ -3295,7 +3262,6 @@ Process::Launch (ProcessLaunchInfo &launch_info)
return error;
}
Error
Process::LoadCore ()
{
@ -3773,7 +3739,6 @@ Process::ConnectRemote (Stream *strm, const char *remote_url)
return error;
}
Error
Process::PrivateResume ()
{
@ -4159,7 +4124,6 @@ Process::GetAddressByteSize () const
return GetTarget().GetArchitecture().GetAddressByteSize();
}
bool
Process::ShouldBroadcastEvent (Event *event_ptr)
{
@ -4293,7 +4257,6 @@ Process::ShouldBroadcastEvent (Event *event_ptr)
ProcessEventData::SetRestartedInEvent(event_ptr, true);
PrivateResume ();
}
}
else
{
@ -4326,7 +4289,6 @@ Process::ShouldBroadcastEvent (Event *event_ptr)
return return_value;
}
bool
Process::StartPrivateStateThread (bool is_secondary_thread)
{
@ -4725,9 +4687,7 @@ Process::ProcessEventData::ProcessEventData (const ProcessSP &process_sp, StateT
m_process_wp = process_sp;
}
Process::ProcessEventData::~ProcessEventData()
{
}
Process::ProcessEventData::~ProcessEventData() = default;
const ConstString &
Process::ProcessEventData::GetFlavorString ()
@ -4858,7 +4818,6 @@ Process::ProcessEventData::DoOnRemoval (Event *event_ptr)
still_should_stop = this_thread_wants_to_stop;
}
}
if (!GetRestarted())
{
@ -5092,7 +5051,6 @@ Process::GetAsyncProfileData (char *buf, size_t buf_size, Error &error)
return bytes_available;
}
//------------------------------------------------------------------
// Process STDIO
//------------------------------------------------------------------
@ -5124,7 +5082,6 @@ Process::GetSTDOUT (char *buf, size_t buf_size, Error &error)
return bytes_available;
}
size_t
Process::GetSTDERR (char *buf, size_t buf_size, Error &error)
{
@ -5175,12 +5132,8 @@ public:
m_read_file.SetDescriptor(GetInputFD(), false);
}
virtual
~IOHandlerProcessSTDIO ()
{
}
~IOHandlerProcessSTDIO() override = default;
// Each IOHandler gets to run until it is done. It should read data
// from the "in" and place output into "out" and "err and return
// when done.
@ -5303,7 +5256,6 @@ public:
void
GotEOF() override
{
}
protected:
@ -5421,6 +5373,7 @@ namespace
m_thread_plan_sp->SetOkayToDiscard(m_okay_to_discard);
}
}
private:
lldb::ThreadPlanSP m_thread_plan_sp;
bool m_already_reset;
@ -5428,7 +5381,7 @@ namespace
bool m_is_master;
bool m_okay_to_discard;
};
}
} // anonymous namespace
ExpressionResults
Process::RunThreadPlan (ExecutionContext &exe_ctx,
@ -5650,7 +5603,6 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx,
}
one_thread_timeout_usec = computed_one_thread_timeout;
all_threads_timeout_usec = timeout_usec - one_thread_timeout_usec;
}
}
@ -5692,8 +5644,7 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx,
#endif
TimeValue one_thread_timeout;
TimeValue final_timeout;
while (1)
{
// We usually want to resume the process if we get to the top of the loop.
@ -5893,7 +5844,6 @@ Process::RunThreadPlan (ExecutionContext &exe_ctx,
keep_going = true;
do_resume = false;
handle_running_event = true;
}
else
{
@ -6475,7 +6425,6 @@ Process::GetThreadStatus (Stream &strm,
Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
if (log)
log->Printf("Process::GetThreadStatus - thread 0x" PRIu64 " vanished while running Thread::GetStatus.");
}
}
return num_thread_infos_dumped;

182
lldb/source/Target/StopInfo.cpp
View File

@ -1,4 +1,4 @@
//===-- StopInfo.cpp ---------------------------------------------*- C++ -*-===//
//===-- StopInfo.cpp --------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -7,14 +7,13 @@
//
//===----------------------------------------------------------------------===//
#include "lldb/Target/StopInfo.h"
// C Includes
// C++ Includes
#include <string>
// Other libraries and framework includes
// Project includes
#include "lldb/Target/StopInfo.h"
#include "lldb/Core/Log.h"
#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
@ -133,6 +132,8 @@ public:
StoreBPInfo();
}
~StopInfoBreakpoint() override = default;
void
StoreBPInfo ()
{
@ -156,12 +157,8 @@ public:
}
}
virtual ~StopInfoBreakpoint ()
{
}
virtual bool
IsValidForOperatingSystemThread (Thread &thread)
bool
IsValidForOperatingSystemThread(Thread &thread) override
{
ProcessSP process_sp (thread.GetProcess());
if (process_sp)
@ -173,14 +170,14 @@ public:
return false;
}
virtual StopReason
GetStopReason () const
StopReason
GetStopReason() const override
{
return eStopReasonBreakpoint;
}
virtual bool
ShouldStopSynchronous (Event *event_ptr)
bool
ShouldStopSynchronous(Event *event_ptr) override
{
ThreadSP thread_sp (m_thread_wp.lock());
if (thread_sp)
@ -212,8 +209,8 @@ public:
return false;
}
virtual bool
DoShouldNotify (Event *event_ptr)
bool
DoShouldNotify(Event *event_ptr) override
{
ThreadSP thread_sp (m_thread_wp.lock());
if (thread_sp)
@ -237,8 +234,8 @@ public:
return true;
}
virtual const char *
GetDescription ()
const char *
GetDescription() override
{
if (m_description.empty())
{
@ -312,7 +309,7 @@ public:
protected:
bool
ShouldStop (Event *event_ptr)
ShouldStop(Event *event_ptr) override
{
// This just reports the work done by PerformAction or the synchronous stop. It should
// only ever get called after they have had a chance to run.
@ -320,8 +317,8 @@ protected:
return m_should_stop;
}
virtual void
PerformAction (Event *event_ptr)
void
PerformAction(Event *event_ptr) override
{
if (!m_should_perform_action)
return;
@ -575,7 +572,6 @@ private:
bool m_was_one_shot;
};
//----------------------------------------------------------------------
// StopInfoWatchpoint
//----------------------------------------------------------------------
@ -597,6 +593,7 @@ public:
process->DisableWatchpoint(watchpoint, notify);
}
}
~WatchpointSentry()
{
if (process && watchpoint)
@ -609,6 +606,7 @@ public:
watchpoint->TurnOffEphemeralMode();
}
}
private:
Process *process;
Watchpoint *watchpoint;
@ -621,19 +619,17 @@ public:
m_watch_hit_addr(watch_hit_addr)
{
}
virtual ~StopInfoWatchpoint ()
{
}
virtual StopReason
GetStopReason () const
~StopInfoWatchpoint() override = default;
StopReason
GetStopReason() const override
{
return eStopReasonWatchpoint;
}
virtual const char *
GetDescription ()
const char *
GetDescription() override
{
if (m_description.empty())
{
@ -645,8 +641,8 @@ public:
}
protected:
virtual bool
ShouldStopSynchronous (Event *event_ptr)
bool
ShouldStopSynchronous(Event *event_ptr) override
{
// ShouldStop() method is idempotent and should not affect hit count.
// See Process::RunPrivateStateThread()->Process()->HandlePrivateEvent()
@ -685,7 +681,7 @@ protected:
}
bool
ShouldStop (Event *event_ptr)
ShouldStop(Event *event_ptr) override
{
// This just reports the work done by PerformAction or the synchronous stop. It should
// only ever get called after they have had a chance to run.
@ -693,8 +689,8 @@ protected:
return m_should_stop;
}
virtual void
PerformAction (Event *event_ptr)
void
PerformAction(Event *event_ptr) override
{
Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS);
// We're going to calculate if we should stop or not in some way during the course of
@ -879,8 +875,6 @@ private:
lldb::addr_t m_watch_hit_addr;
};
//----------------------------------------------------------------------
// StopInfoUnixSignal
//----------------------------------------------------------------------
@ -888,26 +882,22 @@ private:
class StopInfoUnixSignal : public StopInfo
{
public:
StopInfoUnixSignal (Thread &thread, int signo, const char *description) :
StopInfo (thread, signo)
{
SetDescription (description);
}
virtual ~StopInfoUnixSignal ()
{
}
~StopInfoUnixSignal() override = default;
virtual StopReason
GetStopReason () const
StopReason
GetStopReason() const override
{
return eStopReasonSignal;
}
virtual bool
ShouldStopSynchronous (Event *event_ptr)
bool
ShouldStopSynchronous(Event *event_ptr) override
{
ThreadSP thread_sp (m_thread_wp.lock());
if (thread_sp)
@ -915,19 +905,18 @@ public:
return false;
}
virtual bool
ShouldStop (Event *event_ptr)
bool
ShouldStop(Event *event_ptr) override
{
ThreadSP thread_sp (m_thread_wp.lock());
if (thread_sp)
return thread_sp->GetProcess()->GetUnixSignals()->GetShouldStop(m_value);
return false;
}
// If should stop returns false, check if we should notify of this event
virtual bool
DoShouldNotify (Event *event_ptr)
bool
DoShouldNotify(Event *event_ptr) override
{
ThreadSP thread_sp (m_thread_wp.lock());
if (thread_sp)
@ -946,9 +935,8 @@ public:
return true;
}
virtual void
WillResume (lldb::StateType resume_state)
void
WillResume(lldb::StateType resume_state) override
{
ThreadSP thread_sp (m_thread_wp.lock());
if (thread_sp)
@ -958,8 +946,8 @@ public:
}
}
virtual const char *
GetDescription ()
const char *
GetDescription() override
{
if (m_description.empty())
{
@ -986,33 +974,29 @@ public:
class StopInfoTrace : public StopInfo
{
public:
StopInfoTrace (Thread &thread) :
StopInfo (thread, LLDB_INVALID_UID)
{
}
virtual ~StopInfoTrace ()
{
}
virtual StopReason
GetStopReason () const
~StopInfoTrace() override = default;
StopReason
GetStopReason() const override
{
return eStopReasonTrace;
}
virtual const char *
GetDescription ()
const char *
GetDescription() override
{
if (m_description.empty())
return "trace";
return "trace";
else
return m_description.c_str();
}
};
//----------------------------------------------------------------------
// StopInfoException
//----------------------------------------------------------------------
@ -1020,27 +1004,23 @@ public:
class StopInfoException : public StopInfo
{
public:
StopInfoException (Thread &thread, const char *description) :
StopInfo (thread, LLDB_INVALID_UID)
{
if (description)
SetDescription (description);
}
virtual
~StopInfoException ()
{
}
virtual StopReason
GetStopReason () const
~StopInfoException() override = default;
StopReason
GetStopReason() const override
{
return eStopReasonException;
}
virtual const char *
GetDescription ()
const char *
GetDescription() override
{
if (m_description.empty())
return "exception";
@ -1049,7 +1029,6 @@ public:
}
};
//----------------------------------------------------------------------
// StopInfoThreadPlan
//----------------------------------------------------------------------
@ -1057,7 +1036,6 @@ public:
class StopInfoThreadPlan : public StopInfo
{
public:
StopInfoThreadPlan (ThreadPlanSP &plan_sp, ValueObjectSP &return_valobj_sp, ExpressionVariableSP &expression_variable_sp) :
StopInfo (plan_sp->GetThread(), LLDB_INVALID_UID),
m_plan_sp (plan_sp),
@ -1065,19 +1043,17 @@ public:
m_expression_variable_sp (expression_variable_sp)
{
}
virtual ~StopInfoThreadPlan ()
{
}
virtual StopReason
GetStopReason () const
~StopInfoThreadPlan() override = default;
StopReason
GetStopReason() const override
{
return eStopReasonPlanComplete;
}
virtual const char *
GetDescription ()
const char *
GetDescription() override
{
if (m_description.empty())
{
@ -1101,8 +1077,8 @@ public:
}
protected:
virtual bool
ShouldStop (Event *event_ptr)
bool
ShouldStop(Event *event_ptr) override
{
if (m_plan_sp)
return m_plan_sp->ShouldStop(event_ptr);
@ -1119,33 +1095,29 @@ private:
class StopInfoExec : public StopInfo
{
public:
StopInfoExec (Thread &thread) :
StopInfo (thread, LLDB_INVALID_UID),
m_performed_action (false)
{
}
virtual
~StopInfoExec ()
{
}
virtual StopReason
GetStopReason () const
~StopInfoExec() override = default;
StopReason
GetStopReason() const override
{
return eStopReasonExec;
}
virtual const char *
GetDescription ()
const char *
GetDescription() override
{
return "exec";
}
protected:
virtual void
PerformAction (Event *event_ptr)
void
PerformAction(Event *event_ptr) override
{
// Only perform the action once
if (m_performed_action)

79
lldb/source/Target/Target.cpp
View File

@ -7,12 +7,11 @@
//
//===----------------------------------------------------------------------===//
#include "lldb/Target/Target.h"
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Target/Target.h"
#include "lldb/Breakpoint/BreakpointResolver.h"
#include "lldb/Breakpoint/BreakpointResolverAddress.h"
#include "lldb/Breakpoint/BreakpointResolverFileLine.h"
@ -68,9 +67,6 @@ Target::GetStaticBroadcasterClass ()
return class_name;
}
//----------------------------------------------------------------------
// Target constructor
//----------------------------------------------------------------------
Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp, bool is_dummy_target) :
TargetProperties (this),
Broadcaster (&debugger, Target::GetStaticBroadcasterClass().AsCString()),
@ -113,6 +109,14 @@ Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::Plat
}
}
Target::~Target()
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
if (log)
log->Printf ("%p Target::~Target()", static_cast<void*>(this));
DeleteCurrentProcess ();
}
void
Target::PrimeFromDummyTarget(Target *target)
{
@ -131,17 +135,6 @@ Target::PrimeFromDummyTarget(Target *target)
}
}
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
Target::~Target()
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
if (log)
log->Printf ("%p Target::~Target()", static_cast<void*>(this));
DeleteCurrentProcess ();
}
void
Target::Dump (Stream *s, lldb::DescriptionLevel description_level)
{
@ -298,7 +291,6 @@ Target::Destroy()
m_suppress_stop_hooks = false;
}
BreakpointList &
Target::GetBreakpointList(bool internal)
{
@ -345,7 +337,6 @@ Target::CreateSourceRegexBreakpoint (const FileSpecList *containingModules,
return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
}
BreakpointSP
Target::CreateBreakpoint (const FileSpecList *containingModules,
const FileSpec &file,
@ -403,7 +394,6 @@ Target::CreateBreakpoint (const FileSpecList *containingModules,
return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
}
BreakpointSP
Target::CreateBreakpoint (lldb::addr_t addr, bool internal, bool hardware)
{
@ -517,7 +507,6 @@ Target::CreateBreakpoint (const FileSpecList *containingModules,
if (language == lldb::eLanguageTypeUnknown)
language = GetLanguage();
BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL,
func_names,
num_names,
@ -1248,7 +1237,6 @@ Target::SetExecutableModule (ModuleSP& executable_sp, bool get_dependent_files)
}
}
bool
Target::SetArchitecture (const ArchSpec &arch_spec)
{
@ -1519,7 +1507,6 @@ Target::ReadMemory (const Address& addr,
}
if (!resolved_addr.IsValid())
resolved_addr = addr;
if (prefer_file_cache)
{
@ -1606,7 +1593,6 @@ Target::ReadCStringFromMemory (const Address& addr, std::string &out_str, Error
return out_str.size();
}
size_t
Target::ReadCStringFromMemory (const Address& addr, char *dst, size_t dst_max_len, Error &result_error)
{
@ -1901,7 +1887,6 @@ Target::GetSharedModule (const ModuleSpec &module_spec, Error *error_ptr)
return module_sp;
}
TargetSP
Target::CalculateTarget ()
{
@ -1940,11 +1925,8 @@ Target::GetImageSearchPathList ()
}
void
Target::ImageSearchPathsChanged
(
const PathMappingList &path_list,
void *baton
)
Target::ImageSearchPathsChanged(const PathMappingList &path_list,
void *baton)
{
Target *target = (Target *)baton;
ModuleSP exe_module_sp (target->GetExecutableModule());
@ -2090,7 +2072,6 @@ Target::GetScratchClangASTContext(bool create_on_demand)
return nullptr;
}
ClangASTImporter *
Target::GetClangASTImporter()
{
@ -2183,13 +2164,10 @@ Target::GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, const Symbol
}
ExpressionResults
Target::EvaluateExpression
(
const char *expr_cstr,
StackFrame *frame,
lldb::ValueObjectSP &result_valobj_sp,
const EvaluateExpressionOptions& options
)
Target::EvaluateExpression(const char *expr_cstr,
StackFrame *frame,
lldb::ValueObjectSP &result_valobj_sp,
const EvaluateExpressionOptions& options)
{
result_valobj_sp.reset();
@ -2247,7 +2225,6 @@ Target::EvaluateExpression
return execution_results;
}
lldb::ExpressionVariableSP
Target::GetPersistentVariable(const ConstString &name)
{
@ -2866,7 +2843,6 @@ Target::SetSectionLoadAddress (const SectionSP &section_sp, addr_t new_section_l
return true; // Return true if the section load address was changed...
}
return false; // Return false to indicate nothing changed
}
size_t
@ -2933,7 +2909,6 @@ Target::ClearAllLoadedSections ()
m_section_load_history.Clear();
}
Error
Target::Launch (ProcessLaunchInfo &launch_info, Stream *stream)
{
@ -3245,10 +3220,7 @@ Target::StopHook::StopHook (const StopHook &rhs) :
m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get()));
}
Target::StopHook::~StopHook ()
{
}
Target::StopHook::~StopHook() = default;
void
Target::StopHook::SetSpecifier(SymbolContextSpecifier *specifier)
@ -3261,7 +3233,6 @@ Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier)
{
m_thread_spec_ap.reset (specifier);
}
void
Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const
@ -3362,7 +3333,6 @@ g_load_script_from_sym_file_values[] =
{ 0, NULL, NULL }
};
static OptionEnumValueElement
g_memory_module_load_level_values[] =
{
@ -3473,7 +3443,6 @@ enum
ePropertyNonStopModeEnabled
};
class TargetOptionValueProperties : public OptionValueProperties
{
public:
@ -3494,8 +3463,8 @@ public:
{
}
virtual const Property *
GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
const Property *
GetPropertyAtIndex(const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const override
{
// When getting the value for a key from the target options, we will always
// try and grab the setting from the current target if there is one. Else we just
@ -3523,7 +3492,6 @@ public:
}
protected:
void
GetHostEnvironmentIfNeeded () const
{
@ -3622,12 +3590,10 @@ TargetProperties::TargetProperties (Target *target) :
true,
Process::GetGlobalProperties()->GetValueProperties());
}
}
TargetProperties::~TargetProperties ()
{
}
TargetProperties::~TargetProperties() = default;
ArchSpec
TargetProperties::GetDefaultArchitecture () const
{
@ -3666,7 +3632,6 @@ TargetProperties::SetPreferDynamicValue (lldb::DynamicValueType d)
return m_collection_sp->SetPropertyAtIndexAsEnumeration(NULL, idx, d);
}
bool
TargetProperties::GetDisableASLR () const
{
@ -4141,9 +4106,7 @@ Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp, const
{
}
Target::TargetEventData::~TargetEventData()
{
}
Target::TargetEventData::~TargetEventData() = default;
const ConstString &
Target::TargetEventData::GetFlavorString ()

121
lldb/source/Target/Thread.cpp
View File

@ -7,6 +7,10 @@
//
//===----------------------------------------------------------------------===//
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Log.h"
@ -48,11 +52,9 @@
#include "Plugins/Process/Utility/UnwindLLDB.h"
#include "Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h"
using namespace lldb;
using namespace lldb_private;
const ThreadPropertiesSP &
Thread::GetGlobalProperties()
{
@ -82,7 +84,6 @@ enum {
ePropertyEnableThreadTrace
};
class ThreadOptionValueProperties : public OptionValueProperties
{
public:
@ -99,8 +100,8 @@ public:
{
}
virtual const Property *
GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
const Property *
GetPropertyAtIndex(const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const override
{
// When getting the value for a key from the thread options, we will always
// try and grab the setting from the current thread if there is one. Else we just
@ -119,8 +120,6 @@ public:
}
};
ThreadProperties::ThreadProperties (bool is_global) :
Properties ()
{
@ -133,9 +132,7 @@ ThreadProperties::ThreadProperties (bool is_global) :
m_collection_sp.reset (new ThreadOptionValueProperties(Thread::GetGlobalProperties().get()));
}
ThreadProperties::~ThreadProperties()
{
}
ThreadProperties::~ThreadProperties() = default;
const RegularExpression *
ThreadProperties::GetSymbolsToAvoidRegexp()
@ -174,12 +171,10 @@ ThreadProperties::GetStepOutAvoidsNoDebug() const
return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
}
//------------------------------------------------------------------
// Thread Event Data
//------------------------------------------------------------------
const ConstString &
Thread::ThreadEventData::GetFlavorString ()
{
@ -205,14 +200,11 @@ Thread::ThreadEventData::ThreadEventData () :
{
}
Thread::ThreadEventData::~ThreadEventData ()
{
}
Thread::ThreadEventData::~ThreadEventData() = default;
void
Thread::ThreadEventData::Dump (Stream *s) const
{
}
const Thread::ThreadEventData *
@ -309,7 +301,6 @@ Thread::Thread (Process &process, lldb::tid_t tid, bool use_invalid_index_id) :
QueueFundamentalPlan(true);
}
Thread::~Thread()
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
@ -434,7 +425,6 @@ Thread::FunctionOptimizationWarning (StackFrame *frame)
}
}
lldb::StopInfoSP
Thread::GetStopInfo ()
{
@ -513,7 +503,6 @@ Thread::GetPrivateStopInfo ()
return m_stop_info_sp;
}
lldb::StopReason
Thread::GetStopReason()
{
@ -523,7 +512,6 @@ Thread::GetStopReason()
return eStopReasonNone;
}
bool
Thread::StopInfoIsUpToDate() const
{
@ -682,7 +670,6 @@ Thread::SetupForResume ()
{
if (GetResumeState() != eStateSuspended)
{
// If we're at a breakpoint push the step-over breakpoint plan. Do this before
// telling the current plan it will resume, since we might change what the current
// plan is.
@ -933,7 +920,6 @@ Thread::ShouldStop (Event* event_ptr)
break;
}
}
}
}
@ -981,7 +967,6 @@ Thread::ShouldStop (Event* event_ptr)
}
else
{
PopPlan();
current_plan = GetCurrentPlan();
@ -1000,7 +985,6 @@ Thread::ShouldStop (Event* event_ptr)
if (over_ride_stop)
should_stop = false;
}
// One other potential problem is that we set up a master plan, then stop in before it is complete - for instance
@ -1327,7 +1311,6 @@ Thread::QueueThreadPlan (ThreadPlanSP &thread_plan_sp, bool abort_other_plans)
PushPlan (thread_plan_sp);
}
void
Thread::EnableTracer (bool value, bool single_stepping)
{
@ -1378,7 +1361,6 @@ Thread::DiscardUserThreadPlansUpToIndex (uint32_t thread_index)
DiscardThreadPlansUpToPlan(up_to_plan_ptr);
return true;
}
void
Thread::DiscardThreadPlansUpToPlan (lldb::ThreadPlanSP &up_to_plan_sp)
@ -1423,7 +1405,6 @@ Thread::DiscardThreadPlansUpToPlan (ThreadPlan *up_to_plan_ptr)
}
}
}
return;
}
void
@ -1447,7 +1428,6 @@ Thread::DiscardThreadPlans(bool force)
while (1)
{
int master_plan_idx;
bool discard = true;
@ -1466,7 +1446,6 @@ Thread::DiscardThreadPlans(bool force)
// First pop all the dependent plans:
for (int i = m_plan_stack.size() - 1; i > master_plan_idx; i--)
{
// FIXME: Do we need a finalize here, or is the rule that "PrepareForStop"
// for the plan leaves it in a state that it is safe to pop the plan
// with no more notice?
@ -1486,7 +1465,6 @@ Thread::DiscardThreadPlans(bool force)
// If the master plan doesn't want to get discarded, then we're done.
break;
}
}
}
@ -1522,7 +1500,6 @@ Thread::UnwindInnermostExpression()
return error;
}
ThreadPlanSP
Thread::QueueFundamentalPlan (bool abort_other_plans)
{
@ -1532,12 +1509,9 @@ Thread::QueueFundamentalPlan (bool abort_other_plans)
}
ThreadPlanSP
Thread::QueueThreadPlanForStepSingleInstruction
(
bool step_over,
bool abort_other_plans,
bool stop_other_threads
)
Thread::QueueThreadPlanForStepSingleInstruction(bool step_over,
bool abort_other_plans,
bool stop_other_threads)
{
ThreadPlanSP thread_plan_sp (new ThreadPlanStepInstruction (*this, step_over, stop_other_threads, eVoteNoOpinion, eVoteNoOpinion));
QueueThreadPlan (thread_plan_sp, abort_other_plans);
@ -1545,14 +1519,11 @@ Thread::QueueThreadPlanForStepSingleInstruction
}
ThreadPlanSP
Thread::QueueThreadPlanForStepOverRange
(
bool abort_other_plans,
const AddressRange &range,
const SymbolContext &addr_context,
lldb::RunMode stop_other_threads,
LazyBool step_out_avoids_code_withoug_debug_info
)
Thread::QueueThreadPlanForStepOverRange(bool abort_other_plans,
const AddressRange &range,
const SymbolContext &addr_context,
lldb::RunMode stop_other_threads,
LazyBool step_out_avoids_code_withoug_debug_info)
{
ThreadPlanSP thread_plan_sp;
thread_plan_sp.reset (new ThreadPlanStepOverRange (*this, range, addr_context, stop_other_threads, step_out_avoids_code_withoug_debug_info));
@ -1562,16 +1533,13 @@ Thread::QueueThreadPlanForStepOverRange
}
ThreadPlanSP
Thread::QueueThreadPlanForStepInRange
(
bool abort_other_plans,
const AddressRange &range,
const SymbolContext &addr_context,
const char *step_in_target,
lldb::RunMode stop_other_threads,
LazyBool step_in_avoids_code_without_debug_info,
LazyBool step_out_avoids_code_without_debug_info
)
Thread::QueueThreadPlanForStepInRange(bool abort_other_plans,
const AddressRange &range,
const SymbolContext &addr_context,
const char *step_in_target,
lldb::RunMode stop_other_threads,
LazyBool step_in_avoids_code_without_debug_info,
LazyBool step_out_avoids_code_without_debug_info)
{
ThreadPlanSP thread_plan_sp (new ThreadPlanStepInRange (*this,
range,
@ -1588,19 +1556,15 @@ Thread::QueueThreadPlanForStepInRange
return thread_plan_sp;
}
ThreadPlanSP
Thread::QueueThreadPlanForStepOut
(
bool abort_other_plans,
SymbolContext *addr_context,
bool first_insn,
bool stop_other_threads,
Vote stop_vote,
Vote run_vote,
uint32_t frame_idx,
LazyBool step_out_avoids_code_withoug_debug_info
)
Thread::QueueThreadPlanForStepOut(bool abort_other_plans,
SymbolContext *addr_context,
bool first_insn,
bool stop_other_threads,
Vote stop_vote,
Vote run_vote,
uint32_t frame_idx,
LazyBool step_out_avoids_code_withoug_debug_info)
{
ThreadPlanSP thread_plan_sp (new ThreadPlanStepOut (*this,
addr_context,
@ -1623,16 +1587,13 @@ Thread::QueueThreadPlanForStepOut
}
ThreadPlanSP
Thread::QueueThreadPlanForStepOutNoShouldStop
(
bool abort_other_plans,
SymbolContext *addr_context,
bool first_insn,
bool stop_other_threads,
Vote stop_vote,
Vote run_vote,
uint32_t frame_idx
)
Thread::QueueThreadPlanForStepOutNoShouldStop(bool abort_other_plans,
SymbolContext *addr_context,
bool first_insn,
bool stop_other_threads,
Vote stop_vote,
Vote run_vote,
uint32_t frame_idx)
{
ThreadPlanSP thread_plan_sp(new ThreadPlanStepOut (*this,
addr_context,
@ -1709,7 +1670,6 @@ Thread::QueueThreadPlanForStepScripted (bool abort_other_plans,
}
else
return thread_plan_sp;
}
uint32_t
@ -1827,7 +1787,6 @@ Thread::CalculateExecutionContext (ExecutionContext &exe_ctx)
exe_ctx.SetContext (shared_from_this());
}
StackFrameListSP
Thread::GetStackFrameList ()
{
@ -1871,7 +1830,6 @@ Thread::GetFrameWithConcreteFrameIndex (uint32_t unwind_idx)
return GetStackFrameList()->GetFrameWithConcreteFrameIndex (unwind_idx);
}
Error
Thread::ReturnFromFrameWithIndex (uint32_t frame_idx, lldb::ValueObjectSP return_value_sp, bool broadcast)
{
@ -2151,7 +2109,6 @@ Thread::StopReasonAsCString (lldb::StopReason reason)
case eStopReasonInstrumentation: return "instrumentation break";
}
static char unknown_state_string[64];
snprintf(unknown_state_string, sizeof (unknown_state_string), "StopReason = %i", reason);
return unknown_state_string;
@ -2364,7 +2321,6 @@ Thread::GetUnwinder ()
return m_unwinder_ap.get();
}
void
Thread::Flush ()
{
@ -2396,7 +2352,6 @@ Thread::IsStillAtLastBreakpointHit ()
return false;
}
Error
Thread::StepIn (bool source_step,
LazyBool step_in_avoids_code_without_debug_info,