contrib/llvm/tools/lldb/source/API/SBThreadPlan.cpp

   1 //===-- SBThread.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
  10 #include "lldb/API/SBThread.h"
  11
  12 #include "lldb/API/SBSymbolContext.h"
  13 #include "lldb/API/SBFileSpec.h"
  14 #include "lldb/API/SBStream.h"
  15 #include "lldb/Breakpoint/BreakpointLocation.h"
  16 #include "lldb/Core/Debugger.h"
  17 #include "lldb/Core/State.h"
  18 #include "lldb/Core/Stream.h"
  19 #include "lldb/Core/StreamFile.h"
  20 #include "lldb/Core/StructuredData.h"
  21 #include "lldb/Interpreter/CommandInterpreter.h"
  22 #include "lldb/Target/SystemRuntime.h"
  23 #include "lldb/Target/Thread.h"
  24 #include "lldb/Target/ThreadPlan.h"
  25 #include "lldb/Target/Process.h"
  26 #include "lldb/Target/Queue.h"
  27 #include "lldb/Symbol/SymbolContext.h"
  28 #include "lldb/Symbol/CompileUnit.h"
  29 #include "lldb/Target/StopInfo.h"
  30 #include "lldb/Target/Target.h"
  31 #include "lldb/Target/ThreadPlan.h"
  32 #include "lldb/Target/ThreadPlanPython.h"
  33 #include "lldb/Target/ThreadPlanStepInstruction.h"
  34 #include "lldb/Target/ThreadPlanStepOut.h"
  35 #include "lldb/Target/ThreadPlanStepRange.h"
  36 #include "lldb/Target/ThreadPlanStepInRange.h"
  37
  38
  39 #include "lldb/API/SBAddress.h"
  40 #include "lldb/API/SBDebugger.h"
  41 #include "lldb/API/SBEvent.h"
  42 #include "lldb/API/SBFrame.h"
  43 #include "lldb/API/SBProcess.h"
  44 #include "lldb/API/SBThreadPlan.h"
  45 #include "lldb/API/SBValue.h"
  46
  47 using namespace lldb;
  48 using namespace lldb_private;
  49
  50 //----------------------------------------------------------------------
  51 // Constructors
  52 //----------------------------------------------------------------------
  53 SBThreadPlan::SBThreadPlan ()
  54 {
  55 }
  56
  57 SBThreadPlan::SBThreadPlan (const ThreadPlanSP& lldb_object_sp) :
  58     m_opaque_sp (lldb_object_sp)
  59 {
  60 }
  61
  62 SBThreadPlan::SBThreadPlan (const SBThreadPlan &rhs) :
  63     m_opaque_sp (rhs.m_opaque_sp)
  64 {
  65
  66 }
  67
  68 SBThreadPlan::SBThreadPlan (lldb::SBThread &sb_thread, const char *class_name)
  69 {
  70     Thread *thread = sb_thread.get();
  71     if (thread)
  72         m_opaque_sp.reset(new ThreadPlanPython(*thread, class_name));
  73 }
  74
  75 //----------------------------------------------------------------------
  76 // Assignment operator
  77 //----------------------------------------------------------------------
  78
  79 const lldb::SBThreadPlan &
  80 SBThreadPlan::operator = (const SBThreadPlan &rhs)
  81 {
  82     if (this != &rhs)
  83         m_opaque_sp = rhs.m_opaque_sp;
  84     return *this;
  85 }
  86 //----------------------------------------------------------------------
  87 // Destructor
  88 //----------------------------------------------------------------------
  89 SBThreadPlan::~SBThreadPlan()
  90 {
  91 }
  92
  93 lldb_private::ThreadPlan *
  94 SBThreadPlan::get()
  95 {
  96     return m_opaque_sp.get();
  97 }
  98
  99 bool
 100 SBThreadPlan::IsValid() const
 101 {
 102     return m_opaque_sp.get() != NULL;
 103 }
 104
 105 void
 106 SBThreadPlan::Clear ()
 107 {
 108     m_opaque_sp.reset();
 109 }
 110
 111 lldb::StopReason
 112 SBThreadPlan::GetStopReason()
 113 {
 114     return eStopReasonNone;
 115 }
 116
 117 size_t
 118 SBThreadPlan::GetStopReasonDataCount()
 119 {
 120     return 0;
 121 }
 122
 123 uint64_t
 124 SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx)
 125 {
 126     return 0;
 127 }
 128
 129 SBThread
 130 SBThreadPlan::GetThread () const
 131 {
 132     if (m_opaque_sp)
 133     {
 134         return SBThread(m_opaque_sp->GetThread().shared_from_this());
 135     }
 136     else
 137         return SBThread();
 138 }
 139
 140 bool
 141 SBThreadPlan::GetDescription (lldb::SBStream &description) const
 142 {
 143     if (m_opaque_sp)
 144     {
 145         m_opaque_sp->GetDescription(description.get(), eDescriptionLevelFull);
 146     }
 147     else
 148     {
 149         description.Printf("Empty SBThreadPlan");
 150     }
 151     return true;
 152 }
 153
 154 void
 155 SBThreadPlan::SetThreadPlan (const ThreadPlanSP& lldb_object_sp)
 156 {
 157     m_opaque_sp = lldb_object_sp;
 158 }
 159
 160 void
 161 SBThreadPlan::SetPlanComplete (bool success)
 162 {
 163     if (m_opaque_sp)
 164         m_opaque_sp->SetPlanComplete (success);
 165 }
 166
 167 bool
 168 SBThreadPlan::IsPlanComplete()
 169 {
 170     if (m_opaque_sp)
 171         return m_opaque_sp->IsPlanComplete();
 172     else
 173         return true;
 174 }
 175
 176 bool
 177 SBThreadPlan::IsValid()
 178 {
 179     if (m_opaque_sp)
 180         return m_opaque_sp->ValidatePlan(nullptr);
 181     else
 182         return false;
 183 }
 184
 185     // This section allows an SBThreadPlan to push another of the common types of plans...
 186     //
 187     // FIXME, you should only be able to queue thread plans from inside the methods of a
 188     // Scripted Thread Plan.  Need a way to enforce that.
 189
 190 SBThreadPlan
 191 SBThreadPlan::QueueThreadPlanForStepOverRange (SBAddress &sb_start_address,
 192                                                lldb::addr_t size)
 193 {
 194     if (m_opaque_sp)
 195     {
 196         Address *start_address = sb_start_address.get();
 197         if (!start_address)
 198         {
 199             return SBThreadPlan();
 200         }
 201
 202         AddressRange range (*start_address, size);
 203         SymbolContext sc;
 204         start_address->CalculateSymbolContext(&sc);
 205         return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForStepOverRange (false,
 206                                                                                       range,
 207                                                                                       sc,
 208                                                                                       eAllThreads));
 209     }
 210     else
 211     {
 212         return SBThreadPlan();
 213     }
 214 }
 215
 216 SBThreadPlan
 217 SBThreadPlan::QueueThreadPlanForStepInRange (SBAddress &sb_start_address,
 218                                                lldb::addr_t size)
 219 {
 220     if (m_opaque_sp)
 221     {
 222         Address *start_address = sb_start_address.get();
 223         if (!start_address)
 224         {
 225             return SBThreadPlan();
 226         }
 227
 228         AddressRange range (*start_address, size);
 229         SymbolContext sc;
 230         start_address->CalculateSymbolContext(&sc);
 231         return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForStepInRange (false,
 232                                                                                       range,
 233                                                                                       sc,
 234                                                                                       NULL,
 235                                                                                       eAllThreads));
 236     }
 237     else
 238     {
 239         return SBThreadPlan();
 240     }
 241 }
 242
 243 SBThreadPlan
 244 SBThreadPlan::QueueThreadPlanForStepOut (uint32_t frame_idx_to_step_to, bool first_insn)
 245 {
 246     if (m_opaque_sp)
 247     {
 248         SymbolContext sc;
 249         sc = m_opaque_sp->GetThread().GetStackFrameAtIndex(0)->GetSymbolContext(lldb::eSymbolContextEverything);
 250         return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForStepOut (false,
 251                                                                                  &sc,
 252                                                                                  first_insn,
 253                                                                                  false,
 254                                                                                  eVoteYes,
 255                                                                                  eVoteNoOpinion,
 256                                                                                  frame_idx_to_step_to));
 257     }
 258     else
 259     {
 260         return SBThreadPlan();
 261     }
 262 }
 263
 264 SBThreadPlan
 265 SBThreadPlan::QueueThreadPlanForRunToAddress (SBAddress sb_address)
 266 {
 267     if (m_opaque_sp)
 268     {
 269         Address *address = sb_address.get();
 270         if (!address)
 271             return SBThreadPlan();
 272
 273         return SBThreadPlan (m_opaque_sp->GetThread().QueueThreadPlanForRunToAddress (false,
 274                                                                                       *address,
 275                                                                                       false));
 276     }
 277     else
 278     {
 279         return SBThreadPlan();
 280     }
 281 }
 282
 283