1219019Sgabor//===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===// 2219019Sgabor// 3219019Sgabor// The LLVM Compiler Infrastructure 4219019Sgabor// 5219019Sgabor// This file is distributed under the University of Illinois Open Source 6219019Sgabor// License. See LICENSE.TXT for details. 7219019Sgabor// 8219019Sgabor//===----------------------------------------------------------------------===// 9219019Sgabor 10219019Sgabor#include "lldb/lldb-python.h" 11219019Sgabor 12219019Sgabor#include "lldb/API/SBDebugger.h" 13219019Sgabor 14219019Sgabor#include "lldb/lldb-private.h" 15219019Sgabor 16219019Sgabor#include "lldb/API/SBListener.h" 17219019Sgabor#include "lldb/API/SBBroadcaster.h" 18219019Sgabor#include "lldb/API/SBCommandInterpreter.h" 19219019Sgabor#include "lldb/API/SBCommandReturnObject.h" 20219019Sgabor#include "lldb/API/SBError.h" 21219019Sgabor#include "lldb/API/SBEvent.h" 22219019Sgabor#include "lldb/API/SBFrame.h" 23219019Sgabor#include "lldb/API/SBProcess.h" 24219019Sgabor#include "lldb/API/SBSourceManager.h" 25219019Sgabor#include "lldb/API/SBStream.h" 26219019Sgabor#include "lldb/API/SBStringList.h" 27219019Sgabor#include "lldb/API/SBTarget.h" 28219019Sgabor#include "lldb/API/SBThread.h" 29219019Sgabor#include "lldb/API/SBTypeCategory.h" 30219019Sgabor#include "lldb/API/SBTypeFormat.h" 31219019Sgabor#include "lldb/API/SBTypeFilter.h" 32219019Sgabor#include "lldb/API/SBTypeNameSpecifier.h" 33219019Sgabor#include "lldb/API/SBTypeSummary.h" 34219019Sgabor#include "lldb/API/SBTypeSynthetic.h" 35219019Sgabor 36219019Sgabor 37219019Sgabor#include "lldb/Core/Debugger.h" 38219019Sgabor#include "lldb/Core/State.h" 39219019Sgabor#include "lldb/Core/StreamFile.h" 40219019Sgabor#include "lldb/DataFormatters/DataVisualization.h" 41219019Sgabor#include "lldb/Host/DynamicLibrary.h" 42219019Sgabor#include "lldb/Interpreter/Args.h" 43219019Sgabor#include "lldb/Interpreter/CommandInterpreter.h" 44219019Sgabor#include "lldb/Interpreter/OptionGroupPlatform.h" 45219019Sgabor#include "lldb/Target/Process.h" 46219019Sgabor#include "lldb/Target/TargetList.h" 47219019Sgabor 48219019Sgaborusing namespace lldb; 49219019Sgaborusing namespace lldb_private; 50219019Sgabor 51219019Sgabor 52219019SgaborSBInputReader::SBInputReader() 53219019Sgabor{ 54219019Sgabor} 55219019SgaborSBInputReader::~SBInputReader() 56219019Sgabor{ 57219019Sgabor} 58219019Sgabor 59219019SgaborSBError 60219019SgaborSBInputReader::Initialize(lldb::SBDebugger& sb_debugger, unsigned long (*)(void*, lldb::SBInputReader*, lldb::InputReaderAction, char const*, unsigned long), void*, lldb::InputReaderGranularity, char const*, char const*, bool) 61219019Sgabor{ 62219019Sgabor return SBError(); 63219019Sgabor} 64219019Sgabor 65219019Sgaborvoid 66219019SgaborSBInputReader::SetIsDone(bool) 67219019Sgabor{ 68219019Sgabor} 69219019Sgaborbool 70219019SgaborSBInputReader::IsActive() const 71219019Sgabor{ 72219019Sgabor return false; 73219019Sgabor} 74219019Sgabor 75219019Sgaborstatic lldb::DynamicLibrarySP 76219019SgaborLoadPlugin (const lldb::DebuggerSP &debugger_sp, const FileSpec& spec, Error& error) 77219019Sgabor{ 78219019Sgabor lldb::DynamicLibrarySP dynlib_sp(new lldb_private::DynamicLibrary(spec)); 79219019Sgabor if (dynlib_sp && dynlib_sp->IsValid()) 80219019Sgabor { 81219019Sgabor typedef bool (*LLDBCommandPluginInit) (lldb::SBDebugger& debugger); 82219019Sgabor 83219019Sgabor lldb::SBDebugger debugger_sb(debugger_sp); 84219019Sgabor // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) function. 85219019Sgabor // TODO: mangle this differently for your system - on OSX, the first underscore needs to be removed and the second one stays 86219019Sgabor LLDBCommandPluginInit init_func = dynlib_sp->GetSymbol<LLDBCommandPluginInit>("_ZN4lldb16PluginInitializeENS_10SBDebuggerE"); 87219019Sgabor if (init_func) 88219019Sgabor { 89219019Sgabor if (init_func(debugger_sb)) 90219019Sgabor return dynlib_sp; 91219019Sgabor else 92219019Sgabor error.SetErrorString("plug-in refused to load (lldb::PluginInitialize(lldb::SBDebugger) returned false)"); 93219019Sgabor } 94219019Sgabor else 95219019Sgabor { 96219019Sgabor error.SetErrorString("plug-in is missing the required initialization: lldb::PluginInitialize(lldb::SBDebugger)"); 97219019Sgabor } 98219019Sgabor } 99219019Sgabor else 100219019Sgabor { 101219019Sgabor if (spec.Exists()) 102219019Sgabor error.SetErrorString("this file does not represent a loadable dylib"); 103219019Sgabor else 104219019Sgabor error.SetErrorString("no such file"); 105219019Sgabor } 106219019Sgabor return lldb::DynamicLibrarySP(); 107219019Sgabor} 108219019Sgabor 109219019Sgaborvoid 110219019SgaborSBDebugger::Initialize () 111219019Sgabor{ 112219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 113219019Sgabor 114219019Sgabor if (log) 115219019Sgabor log->Printf ("SBDebugger::Initialize ()"); 116219019Sgabor 117219019Sgabor SBCommandInterpreter::InitializeSWIG (); 118219019Sgabor 119219019Sgabor Debugger::Initialize(LoadPlugin); 120219019Sgabor} 121219019Sgabor 122219019Sgaborvoid 123219019SgaborSBDebugger::Terminate () 124219019Sgabor{ 125219019Sgabor Debugger::Terminate(); 126219019Sgabor} 127219019Sgabor 128219019Sgaborvoid 129219019SgaborSBDebugger::Clear () 130219019Sgabor{ 131219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 132219019Sgabor 133219019Sgabor if (log) 134219019Sgabor log->Printf ("SBDebugger(%p)::Clear ()", m_opaque_sp.get()); 135219019Sgabor 136219019Sgabor if (m_opaque_sp) 137219019Sgabor m_opaque_sp->ClearIOHandlers (); 138219019Sgabor 139219019Sgabor m_opaque_sp.reset(); 140219019Sgabor} 141219019Sgabor 142219019SgaborSBDebugger 143219019SgaborSBDebugger::Create() 144219019Sgabor{ 145219019Sgabor return SBDebugger::Create(false, NULL, NULL); 146219019Sgabor} 147219019Sgabor 148219019SgaborSBDebugger 149219019SgaborSBDebugger::Create(bool source_init_files) 150219019Sgabor{ 151219019Sgabor return SBDebugger::Create (source_init_files, NULL, NULL); 152219019Sgabor} 153219019Sgabor 154219019SgaborSBDebugger 155219019SgaborSBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton) 156219019Sgabor 157219019Sgabor{ 158219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 159219019Sgabor 160219019Sgabor SBDebugger debugger; 161219019Sgabor debugger.reset(Debugger::CreateInstance(callback, baton)); 162219019Sgabor 163219019Sgabor if (log) 164219019Sgabor { 165219019Sgabor SBStream sstr; 166219019Sgabor debugger.GetDescription (sstr); 167219019Sgabor log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); 168219019Sgabor } 169219019Sgabor 170219019Sgabor SBCommandInterpreter interp = debugger.GetCommandInterpreter(); 171219019Sgabor if (source_init_files) 172219019Sgabor { 173219019Sgabor interp.get()->SkipLLDBInitFiles(false); 174219019Sgabor interp.get()->SkipAppInitFiles (false); 175219019Sgabor SBCommandReturnObject result; 176219019Sgabor interp.SourceInitFileInHomeDirectory(result); 177219019Sgabor } 178219019Sgabor else 179219019Sgabor { 180219019Sgabor interp.get()->SkipLLDBInitFiles(true); 181219019Sgabor interp.get()->SkipAppInitFiles (true); 182219019Sgabor } 183219019Sgabor return debugger; 184219019Sgabor} 185219019Sgabor 186219019Sgaborvoid 187219019SgaborSBDebugger::Destroy (SBDebugger &debugger) 188219019Sgabor{ 189219019Sgabor Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 190219019Sgabor 191219019Sgabor if (log) 192219019Sgabor { 193219019Sgabor SBStream sstr; 194219019Sgabor debugger.GetDescription (sstr); 195219019Sgabor log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); 196219019Sgabor } 197219019Sgabor 198219019Sgabor Debugger::Destroy (debugger.m_opaque_sp); 199219019Sgabor 200219019Sgabor if (debugger.m_opaque_sp.get() != NULL) 201219019Sgabor debugger.m_opaque_sp.reset(); 202219019Sgabor} 203219019Sgabor 204219019Sgaborvoid 205219019SgaborSBDebugger::MemoryPressureDetected () 206219019Sgabor{ 207219019Sgabor // Since this function can be call asynchronously, we allow it to be 208219019Sgabor // non-mandatory. We have seen deadlocks with this function when called 209219019Sgabor // so we need to safeguard against this until we can determine what is 210219019Sgabor // causing the deadlocks. 211219019Sgabor Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 212219019Sgabor 213219019Sgabor const bool mandatory = false; 214219019Sgabor if (log) 215219019Sgabor { 216219019Sgabor log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory); 217219019Sgabor } 218219019Sgabor 219219019Sgabor ModuleList::RemoveOrphanSharedModules(mandatory); 220219019Sgabor} 221219019Sgabor 222219019SgaborSBDebugger::SBDebugger () : 223219019Sgabor m_opaque_sp () 224219019Sgabor{ 225219019Sgabor} 226219019Sgabor 227219019SgaborSBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) : 228219019Sgabor m_opaque_sp(debugger_sp) 229219019Sgabor{ 230219019Sgabor} 231219019Sgabor 232219019SgaborSBDebugger::SBDebugger(const SBDebugger &rhs) : 233219019Sgabor m_opaque_sp (rhs.m_opaque_sp) 234219019Sgabor{ 235219019Sgabor} 236219019Sgabor 237219019SgaborSBDebugger & 238219019SgaborSBDebugger::operator = (const SBDebugger &rhs) 239219019Sgabor{ 240219019Sgabor if (this != &rhs) 241219019Sgabor { 242219019Sgabor m_opaque_sp = rhs.m_opaque_sp; 243219019Sgabor } 244219019Sgabor return *this; 245219019Sgabor} 246219019Sgabor 247219019SgaborSBDebugger::~SBDebugger () 248219019Sgabor{ 249219019Sgabor} 250219019Sgabor 251219019Sgaborbool 252219019SgaborSBDebugger::IsValid() const 253219019Sgabor{ 254219019Sgabor return m_opaque_sp.get() != NULL; 255219019Sgabor} 256219019Sgabor 257219019Sgabor 258219019Sgaborvoid 259219019SgaborSBDebugger::SetAsync (bool b) 260219019Sgabor{ 261219019Sgabor if (m_opaque_sp) 262219019Sgabor m_opaque_sp->SetAsyncExecution(b); 263219019Sgabor} 264219019Sgabor 265219019Sgaborbool 266219019SgaborSBDebugger::GetAsync () 267219019Sgabor{ 268219019Sgabor if (m_opaque_sp) 269219019Sgabor return m_opaque_sp->GetAsyncExecution(); 270219019Sgabor else 271219019Sgabor return false; 272219019Sgabor} 273219019Sgabor 274219019Sgaborvoid 275219019SgaborSBDebugger::SkipLLDBInitFiles (bool b) 276219019Sgabor{ 277219019Sgabor if (m_opaque_sp) 278219019Sgabor m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b); 279219019Sgabor} 280219019Sgabor 281219019Sgaborvoid 282219019SgaborSBDebugger::SkipAppInitFiles (bool b) 283219019Sgabor{ 284219019Sgabor if (m_opaque_sp) 285219019Sgabor m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b); 286219019Sgabor} 287219019Sgabor 288219019Sgabor// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users 289219019Sgabor// trying to switch modes in the middle of a debugging session. 290219019Sgaborvoid 291219019SgaborSBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership) 292219019Sgabor{ 293219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 294219019Sgabor 295219019Sgabor if (log) 296219019Sgabor log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 297219019Sgabor fh, transfer_ownership); 298219019Sgabor 299219019Sgabor if (m_opaque_sp) 300219019Sgabor m_opaque_sp->SetInputFileHandle (fh, transfer_ownership); 301219019Sgabor} 302219019Sgabor 303219019Sgaborvoid 304219019SgaborSBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership) 305219019Sgabor{ 306219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 307219019Sgabor 308219019Sgabor 309219019Sgabor if (log) 310219019Sgabor log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 311219019Sgabor fh, transfer_ownership); 312219019Sgabor 313219019Sgabor if (m_opaque_sp) 314219019Sgabor m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership); 315219019Sgabor} 316219019Sgabor 317219019Sgaborvoid 318219019SgaborSBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership) 319219019Sgabor{ 320219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 321219019Sgabor 322219019Sgabor 323219019Sgabor if (log) 324219019Sgabor log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 325219019Sgabor fh, transfer_ownership); 326219019Sgabor 327219019Sgabor if (m_opaque_sp) 328219019Sgabor m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership); 329219019Sgabor} 330219019Sgabor 331219019SgaborFILE * 332219019SgaborSBDebugger::GetInputFileHandle () 333219019Sgabor{ 334219019Sgabor if (m_opaque_sp) 335219019Sgabor { 336219019Sgabor StreamFileSP stream_file_sp (m_opaque_sp->GetInputFile()); 337219019Sgabor if (stream_file_sp) 338219019Sgabor return stream_file_sp->GetFile().GetStream(); 339219019Sgabor } 340219019Sgabor return NULL; 341219019Sgabor} 342219019Sgabor 343219019SgaborFILE * 344219019SgaborSBDebugger::GetOutputFileHandle () 345219019Sgabor{ 346219019Sgabor if (m_opaque_sp) 347219019Sgabor { 348219019Sgabor StreamFileSP stream_file_sp (m_opaque_sp->GetOutputFile()); 349219019Sgabor if (stream_file_sp) 350219019Sgabor return stream_file_sp->GetFile().GetStream(); 351219019Sgabor } 352219019Sgabor return NULL; 353219019Sgabor} 354219019Sgabor 355219019SgaborFILE * 356219019SgaborSBDebugger::GetErrorFileHandle () 357219019Sgabor{ 358219019Sgabor if (m_opaque_sp) 359219019Sgabor if (m_opaque_sp) 360219019Sgabor { 361219019Sgabor StreamFileSP stream_file_sp (m_opaque_sp->GetErrorFile()); 362219019Sgabor if (stream_file_sp) 363219019Sgabor return stream_file_sp->GetFile().GetStream(); 364219019Sgabor } 365219019Sgabor return NULL; 366219019Sgabor} 367219019Sgabor 368219019Sgaborvoid 369219019SgaborSBDebugger::SaveInputTerminalState() 370219019Sgabor{ 371219019Sgabor if (m_opaque_sp) 372219019Sgabor m_opaque_sp->SaveInputTerminalState(); 373219019Sgabor} 374219019Sgabor 375219019Sgaborvoid 376219019SgaborSBDebugger::RestoreInputTerminalState() 377219019Sgabor{ 378219019Sgabor if (m_opaque_sp) 379219019Sgabor m_opaque_sp->RestoreInputTerminalState(); 380219019Sgabor 381219019Sgabor} 382219019SgaborSBCommandInterpreter 383219019SgaborSBDebugger::GetCommandInterpreter () 384219019Sgabor{ 385219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 386219019Sgabor 387219019Sgabor SBCommandInterpreter sb_interpreter; 388219019Sgabor if (m_opaque_sp) 389219019Sgabor sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter()); 390219019Sgabor 391219019Sgabor if (log) 392219019Sgabor log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)", 393219019Sgabor m_opaque_sp.get(), sb_interpreter.get()); 394219019Sgabor 395219019Sgabor return sb_interpreter; 396219019Sgabor} 397219019Sgabor 398219019Sgaborvoid 399219019SgaborSBDebugger::HandleCommand (const char *command) 400219019Sgabor{ 401219019Sgabor if (m_opaque_sp) 402219019Sgabor { 403219019Sgabor TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); 404219019Sgabor Mutex::Locker api_locker; 405219019Sgabor if (target_sp) 406219019Sgabor api_locker.Lock(target_sp->GetAPIMutex()); 407219019Sgabor 408219019Sgabor SBCommandInterpreter sb_interpreter(GetCommandInterpreter ()); 409219019Sgabor SBCommandReturnObject result; 410219019Sgabor 411219019Sgabor sb_interpreter.HandleCommand (command, result, false); 412219019Sgabor 413219019Sgabor if (GetErrorFileHandle() != NULL) 414219019Sgabor result.PutError (GetErrorFileHandle()); 415219019Sgabor if (GetOutputFileHandle() != NULL) 416219019Sgabor result.PutOutput (GetOutputFileHandle()); 417219019Sgabor 418219019Sgabor if (m_opaque_sp->GetAsyncExecution() == false) 419219019Sgabor { 420219019Sgabor SBProcess process(GetCommandInterpreter().GetProcess ()); 421219019Sgabor ProcessSP process_sp (process.GetSP()); 422219019Sgabor if (process_sp) 423219019Sgabor { 424219019Sgabor EventSP event_sp; 425219019Sgabor Listener &lldb_listener = m_opaque_sp->GetListener(); 426219019Sgabor while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp)) 427219019Sgabor { 428219019Sgabor SBEvent event(event_sp); 429219019Sgabor HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle()); 430219019Sgabor } 431219019Sgabor } 432219019Sgabor } 433219019Sgabor } 434219019Sgabor} 435219019Sgabor 436219019SgaborSBListener 437219019SgaborSBDebugger::GetListener () 438219019Sgabor{ 439219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 440219019Sgabor 441219019Sgabor SBListener sb_listener; 442219019Sgabor if (m_opaque_sp) 443219019Sgabor sb_listener.reset(&m_opaque_sp->GetListener(), false); 444219019Sgabor 445219019Sgabor if (log) 446219019Sgabor log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", m_opaque_sp.get(), 447219019Sgabor sb_listener.get()); 448219019Sgabor 449219019Sgabor return sb_listener; 450219019Sgabor} 451219019Sgabor 452219019Sgaborvoid 453219019SgaborSBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) 454219019Sgabor{ 455219019Sgabor if (!process.IsValid()) 456219019Sgabor return; 457219019Sgabor 458219019Sgabor TargetSP target_sp (process.GetTarget().GetSP()); 459219019Sgabor if (!target_sp) 460219019Sgabor return; 461219019Sgabor 462219019Sgabor const uint32_t event_type = event.GetType(); 463219019Sgabor char stdio_buffer[1024]; 464219019Sgabor size_t len; 465219019Sgabor 466219019Sgabor Mutex::Locker api_locker (target_sp->GetAPIMutex()); 467219019Sgabor 468219019Sgabor if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) 469219019Sgabor { 470219019Sgabor // Drain stdout when we stop just in case we have any bytes 471219019Sgabor while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0) 472219019Sgabor if (out != NULL) 473219019Sgabor ::fwrite (stdio_buffer, 1, len, out); 474219019Sgabor } 475219019Sgabor 476219019Sgabor if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) 477219019Sgabor { 478219019Sgabor // Drain stderr when we stop just in case we have any bytes 479219019Sgabor while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0) 480219019Sgabor if (err != NULL) 481219019Sgabor ::fwrite (stdio_buffer, 1, len, err); 482219019Sgabor } 483219019Sgabor 484219019Sgabor if (event_type & Process::eBroadcastBitStateChanged) 485219019Sgabor { 486219019Sgabor StateType event_state = SBProcess::GetStateFromEvent (event); 487219019Sgabor 488219019Sgabor if (event_state == eStateInvalid) 489219019Sgabor return; 490219019Sgabor 491219019Sgabor bool is_stopped = StateIsStoppedState (event_state); 492219019Sgabor if (!is_stopped) 493219019Sgabor process.ReportEventState (event, out); 494219019Sgabor } 495219019Sgabor} 496219019Sgabor 497219019SgaborSBSourceManager 498219019SgaborSBDebugger::GetSourceManager () 499219019Sgabor{ 500219019Sgabor SBSourceManager sb_source_manager (*this); 501219019Sgabor return sb_source_manager; 502219019Sgabor} 503219019Sgabor 504219019Sgabor 505219019Sgaborbool 506219019SgaborSBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len) 507219019Sgabor{ 508219019Sgabor if (arch_name && arch_name_len) 509219019Sgabor { 510219019Sgabor ArchSpec default_arch = Target::GetDefaultArchitecture (); 511219019Sgabor 512219019Sgabor if (default_arch.IsValid()) 513219019Sgabor { 514219019Sgabor const std::string &triple_str = default_arch.GetTriple().str(); 515219019Sgabor if (!triple_str.empty()) 516219019Sgabor ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str()); 517219019Sgabor else 518219019Sgabor ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName()); 519219019Sgabor return true; 520219019Sgabor } 521219019Sgabor } 522219019Sgabor if (arch_name && arch_name_len) 523219019Sgabor arch_name[0] = '\0'; 524219019Sgabor return false; 525219019Sgabor} 526219019Sgabor 527219019Sgabor 528219019Sgaborbool 529219019SgaborSBDebugger::SetDefaultArchitecture (const char *arch_name) 530219019Sgabor{ 531219019Sgabor if (arch_name) 532219019Sgabor { 533219019Sgabor ArchSpec arch (arch_name); 534219019Sgabor if (arch.IsValid()) 535219019Sgabor { 536219019Sgabor Target::SetDefaultArchitecture (arch); 537219019Sgabor return true; 538219019Sgabor } 539219019Sgabor } 540219019Sgabor return false; 541219019Sgabor} 542219019Sgabor 543219019SgaborScriptLanguage 544219019SgaborSBDebugger::GetScriptingLanguage (const char *script_language_name) 545219019Sgabor{ 546219019Sgabor 547219019Sgabor return Args::StringToScriptLanguage (script_language_name, 548219019Sgabor eScriptLanguageDefault, 549219019Sgabor NULL); 550219019Sgabor} 551219019Sgabor 552219019Sgaborconst char * 553219019SgaborSBDebugger::GetVersionString () 554219019Sgabor{ 555219019Sgabor return lldb_private::GetVersion(); 556219019Sgabor} 557219019Sgabor 558219019Sgaborconst char * 559219019SgaborSBDebugger::StateAsCString (StateType state) 560219019Sgabor{ 561219019Sgabor return lldb_private::StateAsCString (state); 562219019Sgabor} 563219019Sgabor 564219019Sgaborbool 565219019SgaborSBDebugger::StateIsRunningState (StateType state) 566219019Sgabor{ 567219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 568219019Sgabor 569219019Sgabor const bool result = lldb_private::StateIsRunningState (state); 570219019Sgabor if (log) 571219019Sgabor log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i", 572219019Sgabor StateAsCString (state), result); 573219019Sgabor 574219019Sgabor return result; 575219019Sgabor} 576219019Sgabor 577219019Sgaborbool 578219019SgaborSBDebugger::StateIsStoppedState (StateType state) 579219019Sgabor{ 580219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 581219019Sgabor 582219019Sgabor const bool result = lldb_private::StateIsStoppedState (state, false); 583219019Sgabor if (log) 584219019Sgabor log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i", 585219019Sgabor StateAsCString (state), result); 586219019Sgabor 587219019Sgabor return result; 588219019Sgabor} 589219019Sgabor 590219019Sgaborlldb::SBTarget 591219019SgaborSBDebugger::CreateTarget (const char *filename, 592219019Sgabor const char *target_triple, 593219019Sgabor const char *platform_name, 594219019Sgabor bool add_dependent_modules, 595219019Sgabor lldb::SBError& sb_error) 596219019Sgabor{ 597219019Sgabor SBTarget sb_target; 598219019Sgabor TargetSP target_sp; 599219019Sgabor if (m_opaque_sp) 600219019Sgabor { 601219019Sgabor sb_error.Clear(); 602219019Sgabor OptionGroupPlatform platform_options (false); 603219019Sgabor platform_options.SetPlatformName (platform_name); 604219019Sgabor 605219019Sgabor sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 606219019Sgabor filename, 607219019Sgabor target_triple, 608219019Sgabor add_dependent_modules, 609219019Sgabor &platform_options, 610219019Sgabor target_sp); 611219019Sgabor 612219019Sgabor if (sb_error.Success()) 613219019Sgabor sb_target.SetSP (target_sp); 614219019Sgabor } 615219019Sgabor else 616219019Sgabor { 617219019Sgabor sb_error.SetErrorString("invalid target"); 618219019Sgabor } 619219019Sgabor 620219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 621219019Sgabor if (log) 622219019Sgabor { 623219019Sgabor log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)", 624219019Sgabor m_opaque_sp.get(), 625219019Sgabor filename, 626219019Sgabor target_triple, 627219019Sgabor platform_name, 628219019Sgabor add_dependent_modules, 629219019Sgabor sb_error.GetCString(), 630219019Sgabor target_sp.get()); 631219019Sgabor } 632219019Sgabor 633219019Sgabor return sb_target; 634219019Sgabor} 635219019Sgabor 636219019SgaborSBTarget 637219019SgaborSBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename, 638219019Sgabor const char *target_triple) 639219019Sgabor{ 640219019Sgabor SBTarget sb_target; 641219019Sgabor TargetSP target_sp; 642219019Sgabor if (m_opaque_sp) 643219019Sgabor { 644219019Sgabor const bool add_dependent_modules = true; 645219019Sgabor Error error (m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 646219019Sgabor filename, 647219019Sgabor target_triple, 648219019Sgabor add_dependent_modules, 649219019Sgabor NULL, 650219019Sgabor target_sp)); 651219019Sgabor sb_target.SetSP (target_sp); 652219019Sgabor } 653219019Sgabor 654219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 655219019Sgabor if (log) 656219019Sgabor { 657219019Sgabor log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)", 658219019Sgabor m_opaque_sp.get(), filename, target_triple, target_sp.get()); 659219019Sgabor } 660219019Sgabor 661219019Sgabor return sb_target; 662219019Sgabor} 663219019Sgabor 664219019SgaborSBTarget 665219019SgaborSBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr) 666219019Sgabor{ 667219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 668219019Sgabor 669219019Sgabor SBTarget sb_target; 670219019Sgabor TargetSP target_sp; 671219019Sgabor if (m_opaque_sp) 672219019Sgabor { 673219019Sgabor Error error; 674219019Sgabor const bool add_dependent_modules = true; 675219019Sgabor 676219019Sgabor error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 677219019Sgabor filename, 678219019Sgabor arch_cstr, 679219019Sgabor add_dependent_modules, 680219019Sgabor NULL, 681219019Sgabor target_sp); 682219019Sgabor 683219019Sgabor if (error.Success()) 684219019Sgabor { 685219019Sgabor m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 686219019Sgabor sb_target.SetSP (target_sp); 687219019Sgabor } 688219019Sgabor } 689219019Sgabor 690219019Sgabor if (log) 691219019Sgabor { 692219019Sgabor log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)", 693219019Sgabor m_opaque_sp.get(), filename, arch_cstr, target_sp.get()); 694219019Sgabor } 695219019Sgabor 696219019Sgabor return sb_target; 697219019Sgabor} 698219019Sgabor 699219019SgaborSBTarget 700219019SgaborSBDebugger::CreateTarget (const char *filename) 701219019Sgabor{ 702219019Sgabor SBTarget sb_target; 703219019Sgabor TargetSP target_sp; 704219019Sgabor if (m_opaque_sp) 705219019Sgabor { 706219019Sgabor ArchSpec arch = Target::GetDefaultArchitecture (); 707219019Sgabor Error error; 708219019Sgabor const bool add_dependent_modules = true; 709219019Sgabor 710219019Sgabor PlatformSP platform_sp(m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 711219019Sgabor error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 712219019Sgabor filename, 713219019Sgabor arch, 714219019Sgabor add_dependent_modules, 715219019Sgabor platform_sp, 716219019Sgabor target_sp); 717219019Sgabor 718219019Sgabor if (error.Success()) 719219019Sgabor { 720219019Sgabor m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 721219019Sgabor sb_target.SetSP (target_sp); 722219019Sgabor } 723219019Sgabor } 724219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 725219019Sgabor if (log) 726219019Sgabor { 727219019Sgabor log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", 728219019Sgabor m_opaque_sp.get(), filename, target_sp.get()); 729219019Sgabor } 730219019Sgabor return sb_target; 731219019Sgabor} 732219019Sgabor 733219019Sgaborbool 734219019SgaborSBDebugger::DeleteTarget (lldb::SBTarget &target) 735219019Sgabor{ 736219019Sgabor bool result = false; 737219019Sgabor if (m_opaque_sp) 738219019Sgabor { 739219019Sgabor TargetSP target_sp(target.GetSP()); 740219019Sgabor if (target_sp) 741219019Sgabor { 742219019Sgabor // No need to lock, the target list is thread safe 743219019Sgabor result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp); 744219019Sgabor target_sp->Destroy(); 745219019Sgabor target.Clear(); 746219019Sgabor const bool mandatory = true; 747219019Sgabor ModuleList::RemoveOrphanSharedModules(mandatory); 748219019Sgabor } 749219019Sgabor } 750219019Sgabor 751219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 752219019Sgabor if (log) 753219019Sgabor { 754219019Sgabor log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", m_opaque_sp.get(), target.m_opaque_sp.get(), result); 755219019Sgabor } 756219019Sgabor 757219019Sgabor return result; 758219019Sgabor} 759219019SgaborSBTarget 760219019SgaborSBDebugger::GetTargetAtIndex (uint32_t idx) 761219019Sgabor{ 762219019Sgabor SBTarget sb_target; 763219019Sgabor if (m_opaque_sp) 764219019Sgabor { 765219019Sgabor // No need to lock, the target list is thread safe 766219019Sgabor sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx)); 767219019Sgabor } 768219019Sgabor return sb_target; 769219019Sgabor} 770219019Sgabor 771219019Sgaboruint32_t 772219019SgaborSBDebugger::GetIndexOfTarget (lldb::SBTarget target) 773219019Sgabor{ 774219019Sgabor 775219019Sgabor lldb::TargetSP target_sp = target.GetSP(); 776219019Sgabor if (!target_sp) 777219019Sgabor return UINT32_MAX; 778219019Sgabor 779219019Sgabor if (!m_opaque_sp) 780219019Sgabor return UINT32_MAX; 781219019Sgabor 782219019Sgabor return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP()); 783219019Sgabor} 784219019Sgabor 785219019SgaborSBTarget 786219019SgaborSBDebugger::FindTargetWithProcessID (lldb::pid_t pid) 787219019Sgabor{ 788219019Sgabor SBTarget sb_target; 789219019Sgabor if (m_opaque_sp) 790219019Sgabor { 791219019Sgabor // No need to lock, the target list is thread safe 792219019Sgabor sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid)); 793219019Sgabor } 794219019Sgabor return sb_target; 795219019Sgabor} 796219019Sgabor 797219019SgaborSBTarget 798219019SgaborSBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name) 799219019Sgabor{ 800219019Sgabor SBTarget sb_target; 801219019Sgabor if (m_opaque_sp && filename && filename[0]) 802219019Sgabor { 803219019Sgabor // No need to lock, the target list is thread safe 804219019Sgabor ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get()); 805219019Sgabor TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture (FileSpec(filename, false), arch_name ? &arch : NULL)); 806219019Sgabor sb_target.SetSP (target_sp); 807219019Sgabor } 808219019Sgabor return sb_target; 809219019Sgabor} 810219019Sgabor 811219019SgaborSBTarget 812219019SgaborSBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp) 813219019Sgabor{ 814219019Sgabor SBTarget sb_target; 815219019Sgabor if (m_opaque_sp) 816219019Sgabor { 817219019Sgabor // No need to lock, the target list is thread safe 818219019Sgabor sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get())); 819219019Sgabor } 820219019Sgabor return sb_target; 821219019Sgabor} 822219019Sgabor 823219019Sgabor 824219019Sgaboruint32_t 825219019SgaborSBDebugger::GetNumTargets () 826219019Sgabor{ 827219019Sgabor if (m_opaque_sp) 828219019Sgabor { 829219019Sgabor // No need to lock, the target list is thread safe 830219019Sgabor return m_opaque_sp->GetTargetList().GetNumTargets (); 831219019Sgabor } 832219019Sgabor return 0; 833219019Sgabor} 834219019Sgabor 835219019SgaborSBTarget 836219019SgaborSBDebugger::GetSelectedTarget () 837219019Sgabor{ 838219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 839219019Sgabor 840219019Sgabor SBTarget sb_target; 841219019Sgabor TargetSP target_sp; 842219019Sgabor if (m_opaque_sp) 843219019Sgabor { 844219019Sgabor // No need to lock, the target list is thread safe 845219019Sgabor target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget (); 846219019Sgabor sb_target.SetSP (target_sp); 847219019Sgabor } 848219019Sgabor 849219019Sgabor if (log) 850219019Sgabor { 851219019Sgabor SBStream sstr; 852219019Sgabor sb_target.GetDescription (sstr, eDescriptionLevelBrief); 853219019Sgabor log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), 854219019Sgabor target_sp.get(), sstr.GetData()); 855219019Sgabor } 856219019Sgabor 857219019Sgabor return sb_target; 858219019Sgabor} 859219019Sgabor 860219019Sgaborvoid 861219019SgaborSBDebugger::SetSelectedTarget (SBTarget &sb_target) 862219019Sgabor{ 863219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 864219019Sgabor 865219019Sgabor TargetSP target_sp (sb_target.GetSP()); 866219019Sgabor if (m_opaque_sp) 867219019Sgabor { 868219019Sgabor m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 869219019Sgabor } 870219019Sgabor if (log) 871219019Sgabor { 872219019Sgabor SBStream sstr; 873219019Sgabor sb_target.GetDescription (sstr, eDescriptionLevelBrief); 874219019Sgabor log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), 875219019Sgabor target_sp.get(), sstr.GetData()); 876219019Sgabor } 877219019Sgabor} 878219019Sgabor 879219019SgaborSBPlatform 880219019SgaborSBDebugger::GetSelectedPlatform() 881219019Sgabor{ 882219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 883219019Sgabor 884219019Sgabor SBPlatform sb_platform; 885219019Sgabor DebuggerSP debugger_sp(m_opaque_sp); 886219019Sgabor if (debugger_sp) 887219019Sgabor { 888219019Sgabor sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform()); 889219019Sgabor } 890219019Sgabor if (log) 891219019Sgabor { 892219019Sgabor log->Printf ("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s", m_opaque_sp.get(), 893219019Sgabor sb_platform.GetSP().get(), sb_platform.GetName()); 894219019Sgabor } 895219019Sgabor return sb_platform; 896219019Sgabor} 897219019Sgabor 898219019Sgaborvoid 899219019SgaborSBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) 900219019Sgabor{ 901219019Sgabor Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 902219019Sgabor 903219019Sgabor DebuggerSP debugger_sp(m_opaque_sp); 904219019Sgabor if (debugger_sp) 905219019Sgabor { 906219019Sgabor debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP()); 907219019Sgabor } 908219019Sgabor if (log) 909219019Sgabor { 910219019Sgabor log->Printf ("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)", m_opaque_sp.get(), 911219019Sgabor sb_platform.GetSP().get(), sb_platform.GetName()); 912219019Sgabor } 913219019Sgabor} 914219019Sgabor 915219019Sgaborvoid 916219019SgaborSBDebugger::DispatchInput (void* baton, const void *data, size_t data_len) 917219019Sgabor{ 918219019Sgabor DispatchInput (data,data_len); 919219019Sgabor} 920219019Sgabor 921219019Sgaborvoid 922219019SgaborSBDebugger::DispatchInput (const void *data, size_t data_len) 923219019Sgabor{ 924219019Sgabor// Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 925219019Sgabor// 926219019Sgabor// if (log) 927219019Sgabor// log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")", 928219019Sgabor// m_opaque_sp.get(), 929219019Sgabor// (int) data_len, 930219019Sgabor// (const char *) data, 931219019Sgabor// (uint64_t)data_len); 932219019Sgabor// 933219019Sgabor// if (m_opaque_sp) 934219019Sgabor// m_opaque_sp->DispatchInput ((const char *) data, data_len); 935219019Sgabor} 936219019Sgabor 937219019Sgaborvoid 938219019SgaborSBDebugger::DispatchInputInterrupt () 939219019Sgabor{ 940219019Sgabor if (m_opaque_sp) 941219019Sgabor m_opaque_sp->DispatchInputInterrupt (); 942219019Sgabor} 943219019Sgabor 944219019Sgaborvoid 945219019SgaborSBDebugger::DispatchInputEndOfFile () 946219019Sgabor{ 947219019Sgabor if (m_opaque_sp) 948219019Sgabor m_opaque_sp->DispatchInputEndOfFile (); 949219019Sgabor} 950219019Sgabor 951219019Sgaborvoid 952219019SgaborSBDebugger::PushInputReader (SBInputReader &reader) 953219019Sgabor{ 954219019Sgabor} 955219019Sgabor 956219019Sgaborvoid 957219019SgaborSBDebugger::RunCommandInterpreter (bool auto_handle_events, 958219019Sgabor bool spawn_thread) 959219019Sgabor{ 960219019Sgabor if (m_opaque_sp) 961219019Sgabor m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(auto_handle_events, spawn_thread); 962219019Sgabor} 963219019Sgabor 964219019Sgaborvoid 965219019SgaborSBDebugger::reset (const DebuggerSP &debugger_sp) 966219019Sgabor{ 967219019Sgabor m_opaque_sp = debugger_sp; 968219019Sgabor} 969219019Sgabor 970219019SgaborDebugger * 971219019SgaborSBDebugger::get () const 972219019Sgabor{ 973219019Sgabor return m_opaque_sp.get(); 974219019Sgabor} 975219019Sgabor 976219019SgaborDebugger & 977219019SgaborSBDebugger::ref () const 978219019Sgabor{ 979219019Sgabor assert (m_opaque_sp.get()); 980219019Sgabor return *m_opaque_sp; 981219019Sgabor} 982219019Sgabor 983219019Sgaborconst lldb::DebuggerSP & 984219019SgaborSBDebugger::get_sp () const 985219019Sgabor{ 986219019Sgabor return m_opaque_sp; 987219019Sgabor} 988219019Sgabor 989219019SgaborSBDebugger 990219019SgaborSBDebugger::FindDebuggerWithID (int id) 991219019Sgabor{ 992219019Sgabor // No need to lock, the debugger list is thread safe 993219019Sgabor SBDebugger sb_debugger; 994219019Sgabor DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id); 995219019Sgabor if (debugger_sp) 996219019Sgabor sb_debugger.reset (debugger_sp); 997219019Sgabor return sb_debugger; 998219019Sgabor} 999219019Sgabor 1000219019Sgaborconst char * 1001219019SgaborSBDebugger::GetInstanceName() 1002219019Sgabor{ 1003219019Sgabor if (m_opaque_sp) 1004219019Sgabor return m_opaque_sp->GetInstanceName().AsCString(); 1005219019Sgabor else 1006219019Sgabor return NULL; 1007219019Sgabor} 1008219019Sgabor 1009219019SgaborSBError 1010219019SgaborSBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name) 1011219019Sgabor{ 1012219019Sgabor SBError sb_error; 1013219019Sgabor DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name))); 1014219019Sgabor Error error; 1015219019Sgabor if (debugger_sp) 1016219019Sgabor { 1017219019Sgabor ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1018219019Sgabor error = debugger_sp->SetPropertyValue (&exe_ctx, 1019219019Sgabor eVarSetOperationAssign, 1020219019Sgabor var_name, 1021219019Sgabor value); 1022219019Sgabor } 1023219019Sgabor else 1024219019Sgabor { 1025219019Sgabor error.SetErrorStringWithFormat ("invalid debugger instance name '%s'", debugger_instance_name); 1026219019Sgabor } 1027219019Sgabor if (error.Fail()) 1028219019Sgabor sb_error.SetError(error); 1029219019Sgabor return sb_error; 1030219019Sgabor} 1031219019Sgabor 1032219019SgaborSBStringList 1033219019SgaborSBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name) 1034219019Sgabor{ 1035219019Sgabor SBStringList ret_value; 1036219019Sgabor DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name))); 1037219019Sgabor Error error; 1038219019Sgabor if (debugger_sp) 1039219019Sgabor { 1040219019Sgabor ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext()); 1041219019Sgabor lldb::OptionValueSP value_sp (debugger_sp->GetPropertyValue (&exe_ctx, 1042219019Sgabor var_name, 1043219019Sgabor false, 1044219019Sgabor error)); 1045219019Sgabor if (value_sp) 1046219019Sgabor { 1047219019Sgabor StreamString value_strm; 1048219019Sgabor value_sp->DumpValue (&exe_ctx, value_strm, OptionValue::eDumpOptionValue); 1049 const std::string &value_str = value_strm.GetString(); 1050 if (!value_str.empty()) 1051 { 1052 StringList string_list; 1053 string_list.SplitIntoLines(value_str); 1054 return SBStringList(&string_list); 1055 } 1056 } 1057 } 1058 return SBStringList(); 1059} 1060 1061uint32_t 1062SBDebugger::GetTerminalWidth () const 1063{ 1064 if (m_opaque_sp) 1065 return m_opaque_sp->GetTerminalWidth (); 1066 return 0; 1067} 1068 1069void 1070SBDebugger::SetTerminalWidth (uint32_t term_width) 1071{ 1072 if (m_opaque_sp) 1073 m_opaque_sp->SetTerminalWidth (term_width); 1074} 1075 1076const char * 1077SBDebugger::GetPrompt() const 1078{ 1079 Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1080 1081 if (log) 1082 log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"", m_opaque_sp.get(), 1083 (m_opaque_sp ? m_opaque_sp->GetPrompt() : "")); 1084 1085 if (m_opaque_sp) 1086 return m_opaque_sp->GetPrompt (); 1087 return 0; 1088} 1089 1090void 1091SBDebugger::SetPrompt (const char *prompt) 1092{ 1093 if (m_opaque_sp) 1094 m_opaque_sp->SetPrompt (prompt); 1095} 1096 1097 1098ScriptLanguage 1099SBDebugger::GetScriptLanguage() const 1100{ 1101 if (m_opaque_sp) 1102 return m_opaque_sp->GetScriptLanguage (); 1103 return eScriptLanguageNone; 1104} 1105 1106void 1107SBDebugger::SetScriptLanguage (ScriptLanguage script_lang) 1108{ 1109 if (m_opaque_sp) 1110 { 1111 m_opaque_sp->SetScriptLanguage (script_lang); 1112 } 1113} 1114 1115bool 1116SBDebugger::SetUseExternalEditor (bool value) 1117{ 1118 if (m_opaque_sp) 1119 return m_opaque_sp->SetUseExternalEditor (value); 1120 return false; 1121} 1122 1123bool 1124SBDebugger::GetUseExternalEditor () 1125{ 1126 if (m_opaque_sp) 1127 return m_opaque_sp->GetUseExternalEditor (); 1128 return false; 1129} 1130 1131bool 1132SBDebugger::SetUseColor (bool value) 1133{ 1134 if (m_opaque_sp) 1135 return m_opaque_sp->SetUseColor (value); 1136 return false; 1137} 1138 1139bool 1140SBDebugger::GetUseColor () const 1141{ 1142 if (m_opaque_sp) 1143 return m_opaque_sp->GetUseColor (); 1144 return false; 1145} 1146 1147bool 1148SBDebugger::GetDescription (SBStream &description) 1149{ 1150 Stream &strm = description.ref(); 1151 1152 if (m_opaque_sp) 1153 { 1154 const char *name = m_opaque_sp->GetInstanceName().AsCString(); 1155 user_id_t id = m_opaque_sp->GetID(); 1156 strm.Printf ("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id); 1157 } 1158 else 1159 strm.PutCString ("No value"); 1160 1161 return true; 1162} 1163 1164user_id_t 1165SBDebugger::GetID() 1166{ 1167 if (m_opaque_sp) 1168 return m_opaque_sp->GetID(); 1169 return LLDB_INVALID_UID; 1170} 1171 1172 1173SBError 1174SBDebugger::SetCurrentPlatform (const char *platform_name) 1175{ 1176 SBError sb_error; 1177 if (m_opaque_sp) 1178 { 1179 PlatformSP platform_sp (Platform::Create (platform_name, sb_error.ref())); 1180 1181 if (platform_sp) 1182 { 1183 bool make_selected = true; 1184 m_opaque_sp->GetPlatformList().Append (platform_sp, make_selected); 1185 } 1186 } 1187 return sb_error; 1188} 1189 1190bool 1191SBDebugger::SetCurrentPlatformSDKRoot (const char *sysroot) 1192{ 1193 if (m_opaque_sp) 1194 { 1195 PlatformSP platform_sp (m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 1196 1197 if (platform_sp) 1198 { 1199 platform_sp->SetSDKRootDirectory (ConstString (sysroot)); 1200 return true; 1201 } 1202 } 1203 return false; 1204} 1205 1206bool 1207SBDebugger::GetCloseInputOnEOF () const 1208{ 1209 if (m_opaque_sp) 1210 return m_opaque_sp->GetCloseInputOnEOF (); 1211 return false; 1212} 1213 1214void 1215SBDebugger::SetCloseInputOnEOF (bool b) 1216{ 1217 if (m_opaque_sp) 1218 m_opaque_sp->SetCloseInputOnEOF (b); 1219} 1220 1221SBTypeCategory 1222SBDebugger::GetCategory (const char* category_name) 1223{ 1224 if (!category_name || *category_name == 0) 1225 return SBTypeCategory(); 1226 1227 TypeCategoryImplSP category_sp; 1228 1229 if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false)) 1230 return SBTypeCategory(category_sp); 1231 else 1232 return SBTypeCategory(); 1233} 1234 1235SBTypeCategory 1236SBDebugger::CreateCategory (const char* category_name) 1237{ 1238 if (!category_name || *category_name == 0) 1239 return SBTypeCategory(); 1240 1241 TypeCategoryImplSP category_sp; 1242 1243 if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true)) 1244 return SBTypeCategory(category_sp); 1245 else 1246 return SBTypeCategory(); 1247} 1248 1249bool 1250SBDebugger::DeleteCategory (const char* category_name) 1251{ 1252 if (!category_name || *category_name == 0) 1253 return false; 1254 1255 return DataVisualization::Categories::Delete(ConstString(category_name)); 1256} 1257 1258uint32_t 1259SBDebugger::GetNumCategories() 1260{ 1261 return DataVisualization::Categories::GetCount(); 1262} 1263 1264SBTypeCategory 1265SBDebugger::GetCategoryAtIndex (uint32_t index) 1266{ 1267 return SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)); 1268} 1269 1270SBTypeCategory 1271SBDebugger::GetDefaultCategory() 1272{ 1273 return GetCategory("default"); 1274} 1275 1276SBTypeFormat 1277SBDebugger::GetFormatForType (SBTypeNameSpecifier type_name) 1278{ 1279 SBTypeCategory default_category_sb = GetDefaultCategory(); 1280 if (default_category_sb.GetEnabled()) 1281 return default_category_sb.GetFormatForType(type_name); 1282 return SBTypeFormat(); 1283} 1284 1285#ifndef LLDB_DISABLE_PYTHON 1286SBTypeSummary 1287SBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name) 1288{ 1289 if (type_name.IsValid() == false) 1290 return SBTypeSummary(); 1291 return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())); 1292} 1293#endif // LLDB_DISABLE_PYTHON 1294 1295SBTypeFilter 1296SBDebugger::GetFilterForType (SBTypeNameSpecifier type_name) 1297{ 1298 if (type_name.IsValid() == false) 1299 return SBTypeFilter(); 1300 return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())); 1301} 1302 1303#ifndef LLDB_DISABLE_PYTHON 1304SBTypeSynthetic 1305SBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name) 1306{ 1307 if (type_name.IsValid() == false) 1308 return SBTypeSynthetic(); 1309 return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP())); 1310} 1311#endif // LLDB_DISABLE_PYTHON 1312 1313bool 1314SBDebugger::EnableLog (const char *channel, const char **categories) 1315{ 1316 if (m_opaque_sp) 1317 { 1318 uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 1319 StreamString errors; 1320 return m_opaque_sp->EnableLog (channel, categories, NULL, log_options, errors); 1321 1322 } 1323 else 1324 return false; 1325} 1326 1327void 1328SBDebugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton) 1329{ 1330 if (m_opaque_sp) 1331 { 1332 return m_opaque_sp->SetLoggingCallback (log_callback, baton); 1333 } 1334} 1335 1336 1337