SBDebugger.cpp revision 254721
1254721Semaste//===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===// 2254721Semaste// 3254721Semaste// The LLVM Compiler Infrastructure 4254721Semaste// 5254721Semaste// This file is distributed under the University of Illinois Open Source 6254721Semaste// License. See LICENSE.TXT for details. 7254721Semaste// 8254721Semaste//===----------------------------------------------------------------------===// 9254721Semaste 10254721Semaste#include "lldb/lldb-python.h" 11254721Semaste 12254721Semaste#include "lldb/API/SBDebugger.h" 13254721Semaste 14254721Semaste#include "lldb/lldb-private.h" 15254721Semaste 16254721Semaste#include "lldb/API/SBListener.h" 17254721Semaste#include "lldb/API/SBBroadcaster.h" 18254721Semaste#include "lldb/API/SBCommandInterpreter.h" 19254721Semaste#include "lldb/API/SBCommandReturnObject.h" 20254721Semaste#include "lldb/API/SBError.h" 21254721Semaste#include "lldb/API/SBEvent.h" 22254721Semaste#include "lldb/API/SBFrame.h" 23254721Semaste#include "lldb/API/SBInputReader.h" 24254721Semaste#include "lldb/API/SBProcess.h" 25254721Semaste#include "lldb/API/SBSourceManager.h" 26254721Semaste#include "lldb/API/SBStream.h" 27254721Semaste#include "lldb/API/SBStringList.h" 28254721Semaste#include "lldb/API/SBTarget.h" 29254721Semaste#include "lldb/API/SBThread.h" 30254721Semaste#include "lldb/API/SBTypeCategory.h" 31254721Semaste#include "lldb/API/SBTypeFormat.h" 32254721Semaste#include "lldb/API/SBTypeFilter.h" 33254721Semaste#include "lldb/API/SBTypeNameSpecifier.h" 34254721Semaste#include "lldb/API/SBTypeSummary.h" 35254721Semaste#include "lldb/API/SBTypeSynthetic.h" 36254721Semaste 37254721Semaste 38254721Semaste#include "lldb/Core/Debugger.h" 39254721Semaste#include "lldb/Core/State.h" 40254721Semaste#include "lldb/DataFormatters/DataVisualization.h" 41254721Semaste#include "lldb/Interpreter/Args.h" 42254721Semaste#include "lldb/Interpreter/CommandInterpreter.h" 43254721Semaste#include "lldb/Interpreter/OptionGroupPlatform.h" 44254721Semaste#include "lldb/Target/Process.h" 45254721Semaste#include "lldb/Target/TargetList.h" 46254721Semaste 47254721Semasteusing namespace lldb; 48254721Semasteusing namespace lldb_private; 49254721Semaste 50254721Semastevoid 51254721SemasteSBDebugger::Initialize () 52254721Semaste{ 53254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 54254721Semaste 55254721Semaste if (log) 56254721Semaste log->Printf ("SBDebugger::Initialize ()"); 57254721Semaste 58254721Semaste SBCommandInterpreter::InitializeSWIG (); 59254721Semaste 60254721Semaste Debugger::Initialize(); 61254721Semaste} 62254721Semaste 63254721Semastevoid 64254721SemasteSBDebugger::Terminate () 65254721Semaste{ 66254721Semaste Debugger::Terminate(); 67254721Semaste} 68254721Semaste 69254721Semastevoid 70254721SemasteSBDebugger::Clear () 71254721Semaste{ 72254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 73254721Semaste 74254721Semaste if (log) 75254721Semaste log->Printf ("SBDebugger(%p)::Clear ()", m_opaque_sp.get()); 76254721Semaste 77254721Semaste if (m_opaque_sp) 78254721Semaste m_opaque_sp->CleanUpInputReaders (); 79254721Semaste 80254721Semaste m_opaque_sp.reset(); 81254721Semaste} 82254721Semaste 83254721SemasteSBDebugger 84254721SemasteSBDebugger::Create() 85254721Semaste{ 86254721Semaste return SBDebugger::Create(false, NULL, NULL); 87254721Semaste} 88254721Semaste 89254721SemasteSBDebugger 90254721SemasteSBDebugger::Create(bool source_init_files) 91254721Semaste{ 92254721Semaste return SBDebugger::Create (source_init_files, NULL, NULL); 93254721Semaste} 94254721Semaste 95254721SemasteSBDebugger 96254721SemasteSBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton) 97254721Semaste 98254721Semaste{ 99254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 100254721Semaste 101254721Semaste SBDebugger debugger; 102254721Semaste debugger.reset(Debugger::CreateInstance(callback, baton)); 103254721Semaste 104254721Semaste if (log) 105254721Semaste { 106254721Semaste SBStream sstr; 107254721Semaste debugger.GetDescription (sstr); 108254721Semaste log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); 109254721Semaste } 110254721Semaste 111254721Semaste SBCommandInterpreter interp = debugger.GetCommandInterpreter(); 112254721Semaste if (source_init_files) 113254721Semaste { 114254721Semaste interp.get()->SkipLLDBInitFiles(false); 115254721Semaste interp.get()->SkipAppInitFiles (false); 116254721Semaste SBCommandReturnObject result; 117254721Semaste interp.SourceInitFileInHomeDirectory(result); 118254721Semaste } 119254721Semaste else 120254721Semaste { 121254721Semaste interp.get()->SkipLLDBInitFiles(true); 122254721Semaste interp.get()->SkipAppInitFiles (true); 123254721Semaste } 124254721Semaste return debugger; 125254721Semaste} 126254721Semaste 127254721Semastevoid 128254721SemasteSBDebugger::Destroy (SBDebugger &debugger) 129254721Semaste{ 130254721Semaste Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 131254721Semaste 132254721Semaste if (log) 133254721Semaste { 134254721Semaste SBStream sstr; 135254721Semaste debugger.GetDescription (sstr); 136254721Semaste log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); 137254721Semaste } 138254721Semaste 139254721Semaste Debugger::Destroy (debugger.m_opaque_sp); 140254721Semaste 141254721Semaste if (debugger.m_opaque_sp.get() != NULL) 142254721Semaste debugger.m_opaque_sp.reset(); 143254721Semaste} 144254721Semaste 145254721Semastevoid 146254721SemasteSBDebugger::MemoryPressureDetected () 147254721Semaste{ 148254721Semaste // Since this function can be call asynchronously, we allow it to be 149254721Semaste // non-mandatory. We have seen deadlocks with this function when called 150254721Semaste // so we need to safeguard against this until we can determine what is 151254721Semaste // causing the deadlocks. 152254721Semaste Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 153254721Semaste 154254721Semaste const bool mandatory = false; 155254721Semaste if (log) 156254721Semaste { 157254721Semaste log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory); 158254721Semaste } 159254721Semaste 160254721Semaste ModuleList::RemoveOrphanSharedModules(mandatory); 161254721Semaste} 162254721Semaste 163254721SemasteSBDebugger::SBDebugger () : 164254721Semaste m_opaque_sp () 165254721Semaste{ 166254721Semaste} 167254721Semaste 168254721SemasteSBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) : 169254721Semaste m_opaque_sp(debugger_sp) 170254721Semaste{ 171254721Semaste} 172254721Semaste 173254721SemasteSBDebugger::SBDebugger(const SBDebugger &rhs) : 174254721Semaste m_opaque_sp (rhs.m_opaque_sp) 175254721Semaste{ 176254721Semaste} 177254721Semaste 178254721SemasteSBDebugger & 179254721SemasteSBDebugger::operator = (const SBDebugger &rhs) 180254721Semaste{ 181254721Semaste if (this != &rhs) 182254721Semaste { 183254721Semaste m_opaque_sp = rhs.m_opaque_sp; 184254721Semaste } 185254721Semaste return *this; 186254721Semaste} 187254721Semaste 188254721SemasteSBDebugger::~SBDebugger () 189254721Semaste{ 190254721Semaste} 191254721Semaste 192254721Semastebool 193254721SemasteSBDebugger::IsValid() const 194254721Semaste{ 195254721Semaste return m_opaque_sp.get() != NULL; 196254721Semaste} 197254721Semaste 198254721Semaste 199254721Semastevoid 200254721SemasteSBDebugger::SetAsync (bool b) 201254721Semaste{ 202254721Semaste if (m_opaque_sp) 203254721Semaste m_opaque_sp->SetAsyncExecution(b); 204254721Semaste} 205254721Semaste 206254721Semastebool 207254721SemasteSBDebugger::GetAsync () 208254721Semaste{ 209254721Semaste if (m_opaque_sp) 210254721Semaste return m_opaque_sp->GetAsyncExecution(); 211254721Semaste else 212254721Semaste return false; 213254721Semaste} 214254721Semaste 215254721Semastevoid 216254721SemasteSBDebugger::SkipLLDBInitFiles (bool b) 217254721Semaste{ 218254721Semaste if (m_opaque_sp) 219254721Semaste m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b); 220254721Semaste} 221254721Semaste 222254721Semastevoid 223254721SemasteSBDebugger::SkipAppInitFiles (bool b) 224254721Semaste{ 225254721Semaste if (m_opaque_sp) 226254721Semaste m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b); 227254721Semaste} 228254721Semaste 229254721Semaste// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users 230254721Semaste// trying to switch modes in the middle of a debugging session. 231254721Semastevoid 232254721SemasteSBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership) 233254721Semaste{ 234254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 235254721Semaste 236254721Semaste if (log) 237254721Semaste log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 238254721Semaste fh, transfer_ownership); 239254721Semaste 240254721Semaste if (m_opaque_sp) 241254721Semaste m_opaque_sp->SetInputFileHandle (fh, transfer_ownership); 242254721Semaste} 243254721Semaste 244254721Semastevoid 245254721SemasteSBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership) 246254721Semaste{ 247254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 248254721Semaste 249254721Semaste 250254721Semaste if (log) 251254721Semaste log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 252254721Semaste fh, transfer_ownership); 253254721Semaste 254254721Semaste if (m_opaque_sp) 255254721Semaste m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership); 256254721Semaste} 257254721Semaste 258254721Semastevoid 259254721SemasteSBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership) 260254721Semaste{ 261254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 262254721Semaste 263254721Semaste 264254721Semaste if (log) 265254721Semaste log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), 266254721Semaste fh, transfer_ownership); 267254721Semaste 268254721Semaste if (m_opaque_sp) 269254721Semaste m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership); 270254721Semaste} 271254721Semaste 272254721SemasteFILE * 273254721SemasteSBDebugger::GetInputFileHandle () 274254721Semaste{ 275254721Semaste if (m_opaque_sp) 276254721Semaste return m_opaque_sp->GetInputFile().GetStream(); 277254721Semaste return NULL; 278254721Semaste} 279254721Semaste 280254721SemasteFILE * 281254721SemasteSBDebugger::GetOutputFileHandle () 282254721Semaste{ 283254721Semaste if (m_opaque_sp) 284254721Semaste return m_opaque_sp->GetOutputFile().GetStream(); 285254721Semaste return NULL; 286254721Semaste} 287254721Semaste 288254721SemasteFILE * 289254721SemasteSBDebugger::GetErrorFileHandle () 290254721Semaste{ 291254721Semaste if (m_opaque_sp) 292254721Semaste return m_opaque_sp->GetErrorFile().GetStream(); 293254721Semaste return NULL; 294254721Semaste} 295254721Semaste 296254721Semastevoid 297254721SemasteSBDebugger::SaveInputTerminalState() 298254721Semaste{ 299254721Semaste if (m_opaque_sp) 300254721Semaste m_opaque_sp->SaveInputTerminalState(); 301254721Semaste} 302254721Semaste 303254721Semastevoid 304254721SemasteSBDebugger::RestoreInputTerminalState() 305254721Semaste{ 306254721Semaste if (m_opaque_sp) 307254721Semaste m_opaque_sp->RestoreInputTerminalState(); 308254721Semaste 309254721Semaste} 310254721SemasteSBCommandInterpreter 311254721SemasteSBDebugger::GetCommandInterpreter () 312254721Semaste{ 313254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 314254721Semaste 315254721Semaste SBCommandInterpreter sb_interpreter; 316254721Semaste if (m_opaque_sp) 317254721Semaste sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter()); 318254721Semaste 319254721Semaste if (log) 320254721Semaste log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)", 321254721Semaste m_opaque_sp.get(), sb_interpreter.get()); 322254721Semaste 323254721Semaste return sb_interpreter; 324254721Semaste} 325254721Semaste 326254721Semastevoid 327254721SemasteSBDebugger::HandleCommand (const char *command) 328254721Semaste{ 329254721Semaste if (m_opaque_sp) 330254721Semaste { 331254721Semaste TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); 332254721Semaste Mutex::Locker api_locker; 333254721Semaste if (target_sp) 334254721Semaste api_locker.Lock(target_sp->GetAPIMutex()); 335254721Semaste 336254721Semaste SBCommandInterpreter sb_interpreter(GetCommandInterpreter ()); 337254721Semaste SBCommandReturnObject result; 338254721Semaste 339254721Semaste sb_interpreter.HandleCommand (command, result, false); 340254721Semaste 341254721Semaste if (GetErrorFileHandle() != NULL) 342254721Semaste result.PutError (GetErrorFileHandle()); 343254721Semaste if (GetOutputFileHandle() != NULL) 344254721Semaste result.PutOutput (GetOutputFileHandle()); 345254721Semaste 346254721Semaste if (m_opaque_sp->GetAsyncExecution() == false) 347254721Semaste { 348254721Semaste SBProcess process(GetCommandInterpreter().GetProcess ()); 349254721Semaste ProcessSP process_sp (process.GetSP()); 350254721Semaste if (process_sp) 351254721Semaste { 352254721Semaste EventSP event_sp; 353254721Semaste Listener &lldb_listener = m_opaque_sp->GetListener(); 354254721Semaste while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp)) 355254721Semaste { 356254721Semaste SBEvent event(event_sp); 357254721Semaste HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle()); 358254721Semaste } 359254721Semaste } 360254721Semaste } 361254721Semaste } 362254721Semaste} 363254721Semaste 364254721SemasteSBListener 365254721SemasteSBDebugger::GetListener () 366254721Semaste{ 367254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 368254721Semaste 369254721Semaste SBListener sb_listener; 370254721Semaste if (m_opaque_sp) 371254721Semaste sb_listener.reset(&m_opaque_sp->GetListener(), false); 372254721Semaste 373254721Semaste if (log) 374254721Semaste log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", m_opaque_sp.get(), 375254721Semaste sb_listener.get()); 376254721Semaste 377254721Semaste return sb_listener; 378254721Semaste} 379254721Semaste 380254721Semastevoid 381254721SemasteSBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) 382254721Semaste{ 383254721Semaste if (!process.IsValid()) 384254721Semaste return; 385254721Semaste 386254721Semaste TargetSP target_sp (process.GetTarget().GetSP()); 387254721Semaste if (!target_sp) 388254721Semaste return; 389254721Semaste 390254721Semaste const uint32_t event_type = event.GetType(); 391254721Semaste char stdio_buffer[1024]; 392254721Semaste size_t len; 393254721Semaste 394254721Semaste Mutex::Locker api_locker (target_sp->GetAPIMutex()); 395254721Semaste 396254721Semaste if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) 397254721Semaste { 398254721Semaste // Drain stdout when we stop just in case we have any bytes 399254721Semaste while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0) 400254721Semaste if (out != NULL) 401254721Semaste ::fwrite (stdio_buffer, 1, len, out); 402254721Semaste } 403254721Semaste 404254721Semaste if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) 405254721Semaste { 406254721Semaste // Drain stderr when we stop just in case we have any bytes 407254721Semaste while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0) 408254721Semaste if (err != NULL) 409254721Semaste ::fwrite (stdio_buffer, 1, len, err); 410254721Semaste } 411254721Semaste 412254721Semaste if (event_type & Process::eBroadcastBitStateChanged) 413254721Semaste { 414254721Semaste StateType event_state = SBProcess::GetStateFromEvent (event); 415254721Semaste 416254721Semaste if (event_state == eStateInvalid) 417254721Semaste return; 418254721Semaste 419254721Semaste bool is_stopped = StateIsStoppedState (event_state); 420254721Semaste if (!is_stopped) 421254721Semaste process.ReportEventState (event, out); 422254721Semaste } 423254721Semaste} 424254721Semaste 425254721SemasteSBSourceManager 426254721SemasteSBDebugger::GetSourceManager () 427254721Semaste{ 428254721Semaste SBSourceManager sb_source_manager (*this); 429254721Semaste return sb_source_manager; 430254721Semaste} 431254721Semaste 432254721Semaste 433254721Semastebool 434254721SemasteSBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len) 435254721Semaste{ 436254721Semaste if (arch_name && arch_name_len) 437254721Semaste { 438254721Semaste ArchSpec default_arch = Target::GetDefaultArchitecture (); 439254721Semaste 440254721Semaste if (default_arch.IsValid()) 441254721Semaste { 442254721Semaste const std::string &triple_str = default_arch.GetTriple().str(); 443254721Semaste if (!triple_str.empty()) 444254721Semaste ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str()); 445254721Semaste else 446254721Semaste ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName()); 447254721Semaste return true; 448254721Semaste } 449254721Semaste } 450254721Semaste if (arch_name && arch_name_len) 451254721Semaste arch_name[0] = '\0'; 452254721Semaste return false; 453254721Semaste} 454254721Semaste 455254721Semaste 456254721Semastebool 457254721SemasteSBDebugger::SetDefaultArchitecture (const char *arch_name) 458254721Semaste{ 459254721Semaste if (arch_name) 460254721Semaste { 461254721Semaste ArchSpec arch (arch_name); 462254721Semaste if (arch.IsValid()) 463254721Semaste { 464254721Semaste Target::SetDefaultArchitecture (arch); 465254721Semaste return true; 466254721Semaste } 467254721Semaste } 468254721Semaste return false; 469254721Semaste} 470254721Semaste 471254721SemasteScriptLanguage 472254721SemasteSBDebugger::GetScriptingLanguage (const char *script_language_name) 473254721Semaste{ 474254721Semaste 475254721Semaste return Args::StringToScriptLanguage (script_language_name, 476254721Semaste eScriptLanguageDefault, 477254721Semaste NULL); 478254721Semaste} 479254721Semaste 480254721Semasteconst char * 481254721SemasteSBDebugger::GetVersionString () 482254721Semaste{ 483254721Semaste return GetVersion(); 484254721Semaste} 485254721Semaste 486254721Semasteconst char * 487254721SemasteSBDebugger::StateAsCString (StateType state) 488254721Semaste{ 489254721Semaste return lldb_private::StateAsCString (state); 490254721Semaste} 491254721Semaste 492254721Semastebool 493254721SemasteSBDebugger::StateIsRunningState (StateType state) 494254721Semaste{ 495254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 496254721Semaste 497254721Semaste const bool result = lldb_private::StateIsRunningState (state); 498254721Semaste if (log) 499254721Semaste log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i", 500254721Semaste StateAsCString (state), result); 501254721Semaste 502254721Semaste return result; 503254721Semaste} 504254721Semaste 505254721Semastebool 506254721SemasteSBDebugger::StateIsStoppedState (StateType state) 507254721Semaste{ 508254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 509254721Semaste 510254721Semaste const bool result = lldb_private::StateIsStoppedState (state, false); 511254721Semaste if (log) 512254721Semaste log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i", 513254721Semaste StateAsCString (state), result); 514254721Semaste 515254721Semaste return result; 516254721Semaste} 517254721Semaste 518254721Semastelldb::SBTarget 519254721SemasteSBDebugger::CreateTarget (const char *filename, 520254721Semaste const char *target_triple, 521254721Semaste const char *platform_name, 522254721Semaste bool add_dependent_modules, 523254721Semaste lldb::SBError& sb_error) 524254721Semaste{ 525254721Semaste SBTarget sb_target; 526254721Semaste TargetSP target_sp; 527254721Semaste if (m_opaque_sp) 528254721Semaste { 529254721Semaste sb_error.Clear(); 530254721Semaste OptionGroupPlatform platform_options (false); 531254721Semaste platform_options.SetPlatformName (platform_name); 532254721Semaste 533254721Semaste sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 534254721Semaste filename, 535254721Semaste target_triple, 536254721Semaste add_dependent_modules, 537254721Semaste &platform_options, 538254721Semaste target_sp); 539254721Semaste 540254721Semaste if (sb_error.Success()) 541254721Semaste sb_target.SetSP (target_sp); 542254721Semaste } 543254721Semaste else 544254721Semaste { 545254721Semaste sb_error.SetErrorString("invalid target"); 546254721Semaste } 547254721Semaste 548254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 549254721Semaste if (log) 550254721Semaste { 551254721Semaste log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)", 552254721Semaste m_opaque_sp.get(), 553254721Semaste filename, 554254721Semaste target_triple, 555254721Semaste platform_name, 556254721Semaste add_dependent_modules, 557254721Semaste sb_error.GetCString(), 558254721Semaste target_sp.get()); 559254721Semaste } 560254721Semaste 561254721Semaste return sb_target; 562254721Semaste} 563254721Semaste 564254721SemasteSBTarget 565254721SemasteSBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename, 566254721Semaste const char *target_triple) 567254721Semaste{ 568254721Semaste SBTarget sb_target; 569254721Semaste TargetSP target_sp; 570254721Semaste if (m_opaque_sp) 571254721Semaste { 572254721Semaste const bool add_dependent_modules = true; 573254721Semaste Error error (m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 574254721Semaste filename, 575254721Semaste target_triple, 576254721Semaste add_dependent_modules, 577254721Semaste NULL, 578254721Semaste target_sp)); 579254721Semaste sb_target.SetSP (target_sp); 580254721Semaste } 581254721Semaste 582254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 583254721Semaste if (log) 584254721Semaste { 585254721Semaste log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)", 586254721Semaste m_opaque_sp.get(), filename, target_triple, target_sp.get()); 587254721Semaste } 588254721Semaste 589254721Semaste return sb_target; 590254721Semaste} 591254721Semaste 592254721SemasteSBTarget 593254721SemasteSBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr) 594254721Semaste{ 595254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 596254721Semaste 597254721Semaste SBTarget sb_target; 598254721Semaste TargetSP target_sp; 599254721Semaste if (m_opaque_sp) 600254721Semaste { 601254721Semaste Error error; 602254721Semaste const bool add_dependent_modules = true; 603254721Semaste 604254721Semaste error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 605254721Semaste filename, 606254721Semaste arch_cstr, 607254721Semaste add_dependent_modules, 608254721Semaste NULL, 609254721Semaste target_sp); 610254721Semaste 611254721Semaste if (error.Success()) 612254721Semaste { 613254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 614254721Semaste sb_target.SetSP (target_sp); 615254721Semaste } 616254721Semaste } 617254721Semaste 618254721Semaste if (log) 619254721Semaste { 620254721Semaste log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)", 621254721Semaste m_opaque_sp.get(), filename, arch_cstr, target_sp.get()); 622254721Semaste } 623254721Semaste 624254721Semaste return sb_target; 625254721Semaste} 626254721Semaste 627254721SemasteSBTarget 628254721SemasteSBDebugger::CreateTarget (const char *filename) 629254721Semaste{ 630254721Semaste SBTarget sb_target; 631254721Semaste TargetSP target_sp; 632254721Semaste if (m_opaque_sp) 633254721Semaste { 634254721Semaste ArchSpec arch = Target::GetDefaultArchitecture (); 635254721Semaste Error error; 636254721Semaste const bool add_dependent_modules = true; 637254721Semaste 638254721Semaste PlatformSP platform_sp(m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 639254721Semaste error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, 640254721Semaste filename, 641254721Semaste arch, 642254721Semaste add_dependent_modules, 643254721Semaste platform_sp, 644254721Semaste target_sp); 645254721Semaste 646254721Semaste if (error.Success()) 647254721Semaste { 648254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 649254721Semaste sb_target.SetSP (target_sp); 650254721Semaste } 651254721Semaste } 652254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 653254721Semaste if (log) 654254721Semaste { 655254721Semaste log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", 656254721Semaste m_opaque_sp.get(), filename, target_sp.get()); 657254721Semaste } 658254721Semaste return sb_target; 659254721Semaste} 660254721Semaste 661254721Semastebool 662254721SemasteSBDebugger::DeleteTarget (lldb::SBTarget &target) 663254721Semaste{ 664254721Semaste bool result = false; 665254721Semaste if (m_opaque_sp) 666254721Semaste { 667254721Semaste TargetSP target_sp(target.GetSP()); 668254721Semaste if (target_sp) 669254721Semaste { 670254721Semaste // No need to lock, the target list is thread safe 671254721Semaste result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp); 672254721Semaste target_sp->Destroy(); 673254721Semaste target.Clear(); 674254721Semaste const bool mandatory = true; 675254721Semaste ModuleList::RemoveOrphanSharedModules(mandatory); 676254721Semaste } 677254721Semaste } 678254721Semaste 679254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 680254721Semaste if (log) 681254721Semaste { 682254721Semaste log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", m_opaque_sp.get(), target.m_opaque_sp.get(), result); 683254721Semaste } 684254721Semaste 685254721Semaste return result; 686254721Semaste} 687254721SemasteSBTarget 688254721SemasteSBDebugger::GetTargetAtIndex (uint32_t idx) 689254721Semaste{ 690254721Semaste SBTarget sb_target; 691254721Semaste if (m_opaque_sp) 692254721Semaste { 693254721Semaste // No need to lock, the target list is thread safe 694254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx)); 695254721Semaste } 696254721Semaste return sb_target; 697254721Semaste} 698254721Semaste 699254721Semasteuint32_t 700254721SemasteSBDebugger::GetIndexOfTarget (lldb::SBTarget target) 701254721Semaste{ 702254721Semaste 703254721Semaste lldb::TargetSP target_sp = target.GetSP(); 704254721Semaste if (!target_sp) 705254721Semaste return UINT32_MAX; 706254721Semaste 707254721Semaste if (!m_opaque_sp) 708254721Semaste return UINT32_MAX; 709254721Semaste 710254721Semaste return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP()); 711254721Semaste} 712254721Semaste 713254721SemasteSBTarget 714254721SemasteSBDebugger::FindTargetWithProcessID (pid_t pid) 715254721Semaste{ 716254721Semaste SBTarget sb_target; 717254721Semaste if (m_opaque_sp) 718254721Semaste { 719254721Semaste // No need to lock, the target list is thread safe 720254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid)); 721254721Semaste } 722254721Semaste return sb_target; 723254721Semaste} 724254721Semaste 725254721SemasteSBTarget 726254721SemasteSBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name) 727254721Semaste{ 728254721Semaste SBTarget sb_target; 729254721Semaste if (m_opaque_sp && filename && filename[0]) 730254721Semaste { 731254721Semaste // No need to lock, the target list is thread safe 732254721Semaste ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get()); 733254721Semaste TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture (FileSpec(filename, false), arch_name ? &arch : NULL)); 734254721Semaste sb_target.SetSP (target_sp); 735254721Semaste } 736254721Semaste return sb_target; 737254721Semaste} 738254721Semaste 739254721SemasteSBTarget 740254721SemasteSBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp) 741254721Semaste{ 742254721Semaste SBTarget sb_target; 743254721Semaste if (m_opaque_sp) 744254721Semaste { 745254721Semaste // No need to lock, the target list is thread safe 746254721Semaste sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get())); 747254721Semaste } 748254721Semaste return sb_target; 749254721Semaste} 750254721Semaste 751254721Semaste 752254721Semasteuint32_t 753254721SemasteSBDebugger::GetNumTargets () 754254721Semaste{ 755254721Semaste if (m_opaque_sp) 756254721Semaste { 757254721Semaste // No need to lock, the target list is thread safe 758254721Semaste return m_opaque_sp->GetTargetList().GetNumTargets (); 759254721Semaste } 760254721Semaste return 0; 761254721Semaste} 762254721Semaste 763254721SemasteSBTarget 764254721SemasteSBDebugger::GetSelectedTarget () 765254721Semaste{ 766254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 767254721Semaste 768254721Semaste SBTarget sb_target; 769254721Semaste TargetSP target_sp; 770254721Semaste if (m_opaque_sp) 771254721Semaste { 772254721Semaste // No need to lock, the target list is thread safe 773254721Semaste target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget (); 774254721Semaste sb_target.SetSP (target_sp); 775254721Semaste } 776254721Semaste 777254721Semaste if (log) 778254721Semaste { 779254721Semaste SBStream sstr; 780254721Semaste sb_target.GetDescription (sstr, eDescriptionLevelBrief); 781254721Semaste log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), 782254721Semaste target_sp.get(), sstr.GetData()); 783254721Semaste } 784254721Semaste 785254721Semaste return sb_target; 786254721Semaste} 787254721Semaste 788254721Semastevoid 789254721SemasteSBDebugger::SetSelectedTarget (SBTarget &sb_target) 790254721Semaste{ 791254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 792254721Semaste 793254721Semaste TargetSP target_sp (sb_target.GetSP()); 794254721Semaste if (m_opaque_sp) 795254721Semaste { 796254721Semaste m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); 797254721Semaste } 798254721Semaste if (log) 799254721Semaste { 800254721Semaste SBStream sstr; 801254721Semaste sb_target.GetDescription (sstr, eDescriptionLevelBrief); 802254721Semaste log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), 803254721Semaste target_sp.get(), sstr.GetData()); 804254721Semaste } 805254721Semaste} 806254721Semaste 807254721Semastevoid 808254721SemasteSBDebugger::DispatchInput (void* baton, const void *data, size_t data_len) 809254721Semaste{ 810254721Semaste DispatchInput (data,data_len); 811254721Semaste} 812254721Semaste 813254721Semastevoid 814254721SemasteSBDebugger::DispatchInput (const void *data, size_t data_len) 815254721Semaste{ 816254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 817254721Semaste 818254721Semaste if (log) 819254721Semaste log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")", 820254721Semaste m_opaque_sp.get(), 821254721Semaste (int) data_len, 822254721Semaste (const char *) data, 823254721Semaste (uint64_t)data_len); 824254721Semaste 825254721Semaste if (m_opaque_sp) 826254721Semaste m_opaque_sp->DispatchInput ((const char *) data, data_len); 827254721Semaste} 828254721Semaste 829254721Semastevoid 830254721SemasteSBDebugger::DispatchInputInterrupt () 831254721Semaste{ 832254721Semaste if (m_opaque_sp) 833254721Semaste m_opaque_sp->DispatchInputInterrupt (); 834254721Semaste} 835254721Semaste 836254721Semastevoid 837254721SemasteSBDebugger::DispatchInputEndOfFile () 838254721Semaste{ 839254721Semaste if (m_opaque_sp) 840254721Semaste m_opaque_sp->DispatchInputEndOfFile (); 841254721Semaste} 842254721Semaste 843254721Semastebool 844254721SemasteSBDebugger::InputReaderIsTopReader (const lldb::SBInputReader &reader) 845254721Semaste{ 846254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 847254721Semaste 848254721Semaste if (log) 849254721Semaste log->Printf ("SBDebugger(%p)::InputReaderIsTopReader (SBInputReader(%p))", m_opaque_sp.get(), &reader); 850254721Semaste 851254721Semaste if (m_opaque_sp && reader.IsValid()) 852254721Semaste { 853254721Semaste InputReaderSP reader_sp (*reader); 854254721Semaste return m_opaque_sp->InputReaderIsTopReader (reader_sp); 855254721Semaste } 856254721Semaste 857254721Semaste return false; 858254721Semaste} 859254721Semaste 860254721Semaste 861254721Semastevoid 862254721SemasteSBDebugger::PushInputReader (SBInputReader &reader) 863254721Semaste{ 864254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 865254721Semaste 866254721Semaste if (log) 867254721Semaste log->Printf ("SBDebugger(%p)::PushInputReader (SBInputReader(%p))", m_opaque_sp.get(), &reader); 868254721Semaste 869254721Semaste if (m_opaque_sp && reader.IsValid()) 870254721Semaste { 871254721Semaste TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); 872254721Semaste Mutex::Locker api_locker; 873254721Semaste if (target_sp) 874254721Semaste api_locker.Lock(target_sp->GetAPIMutex()); 875254721Semaste InputReaderSP reader_sp(*reader); 876254721Semaste m_opaque_sp->PushInputReader (reader_sp); 877254721Semaste } 878254721Semaste} 879254721Semaste 880254721Semastevoid 881254721SemasteSBDebugger::NotifyTopInputReader (InputReaderAction notification) 882254721Semaste{ 883254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 884254721Semaste 885254721Semaste if (log) 886254721Semaste log->Printf ("SBDebugger(%p)::NotifyTopInputReader (%d)", m_opaque_sp.get(), notification); 887254721Semaste 888254721Semaste if (m_opaque_sp) 889254721Semaste m_opaque_sp->NotifyTopInputReader (notification); 890254721Semaste} 891254721Semaste 892254721Semastevoid 893254721SemasteSBDebugger::reset (const DebuggerSP &debugger_sp) 894254721Semaste{ 895254721Semaste m_opaque_sp = debugger_sp; 896254721Semaste} 897254721Semaste 898254721SemasteDebugger * 899254721SemasteSBDebugger::get () const 900254721Semaste{ 901254721Semaste return m_opaque_sp.get(); 902254721Semaste} 903254721Semaste 904254721SemasteDebugger & 905254721SemasteSBDebugger::ref () const 906254721Semaste{ 907254721Semaste assert (m_opaque_sp.get()); 908254721Semaste return *m_opaque_sp; 909254721Semaste} 910254721Semaste 911254721Semasteconst lldb::DebuggerSP & 912254721SemasteSBDebugger::get_sp () const 913254721Semaste{ 914254721Semaste return m_opaque_sp; 915254721Semaste} 916254721Semaste 917254721SemasteSBDebugger 918254721SemasteSBDebugger::FindDebuggerWithID (int id) 919254721Semaste{ 920254721Semaste // No need to lock, the debugger list is thread safe 921254721Semaste SBDebugger sb_debugger; 922254721Semaste DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id); 923254721Semaste if (debugger_sp) 924254721Semaste sb_debugger.reset (debugger_sp); 925254721Semaste return sb_debugger; 926254721Semaste} 927254721Semaste 928254721Semasteconst char * 929254721SemasteSBDebugger::GetInstanceName() 930254721Semaste{ 931254721Semaste if (m_opaque_sp) 932254721Semaste return m_opaque_sp->GetInstanceName().AsCString(); 933254721Semaste else 934254721Semaste return NULL; 935254721Semaste} 936254721Semaste 937254721SemasteSBError 938254721SemasteSBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name) 939254721Semaste{ 940254721Semaste SBError sb_error; 941254721Semaste DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name))); 942254721Semaste Error error; 943254721Semaste if (debugger_sp) 944254721Semaste { 945254721Semaste ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext()); 946254721Semaste error = debugger_sp->SetPropertyValue (&exe_ctx, 947254721Semaste eVarSetOperationAssign, 948254721Semaste var_name, 949254721Semaste value); 950254721Semaste } 951254721Semaste else 952254721Semaste { 953254721Semaste error.SetErrorStringWithFormat ("invalid debugger instance name '%s'", debugger_instance_name); 954254721Semaste } 955254721Semaste if (error.Fail()) 956254721Semaste sb_error.SetError(error); 957254721Semaste return sb_error; 958254721Semaste} 959254721Semaste 960254721SemasteSBStringList 961254721SemasteSBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name) 962254721Semaste{ 963254721Semaste SBStringList ret_value; 964254721Semaste DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name))); 965254721Semaste Error error; 966254721Semaste if (debugger_sp) 967254721Semaste { 968254721Semaste ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext()); 969254721Semaste lldb::OptionValueSP value_sp (debugger_sp->GetPropertyValue (&exe_ctx, 970254721Semaste var_name, 971254721Semaste false, 972254721Semaste error)); 973254721Semaste if (value_sp) 974254721Semaste { 975254721Semaste StreamString value_strm; 976254721Semaste value_sp->DumpValue (&exe_ctx, value_strm, OptionValue::eDumpOptionValue); 977254721Semaste const std::string &value_str = value_strm.GetString(); 978254721Semaste if (!value_str.empty()) 979254721Semaste { 980254721Semaste StringList string_list; 981254721Semaste string_list.SplitIntoLines(value_str.c_str(), value_str.size()); 982254721Semaste return SBStringList(&string_list); 983254721Semaste } 984254721Semaste } 985254721Semaste } 986254721Semaste return SBStringList(); 987254721Semaste} 988254721Semaste 989254721Semasteuint32_t 990254721SemasteSBDebugger::GetTerminalWidth () const 991254721Semaste{ 992254721Semaste if (m_opaque_sp) 993254721Semaste return m_opaque_sp->GetTerminalWidth (); 994254721Semaste return 0; 995254721Semaste} 996254721Semaste 997254721Semastevoid 998254721SemasteSBDebugger::SetTerminalWidth (uint32_t term_width) 999254721Semaste{ 1000254721Semaste if (m_opaque_sp) 1001254721Semaste m_opaque_sp->SetTerminalWidth (term_width); 1002254721Semaste} 1003254721Semaste 1004254721Semasteconst char * 1005254721SemasteSBDebugger::GetPrompt() const 1006254721Semaste{ 1007254721Semaste Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 1008254721Semaste 1009254721Semaste if (log) 1010254721Semaste log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"", m_opaque_sp.get(), 1011254721Semaste (m_opaque_sp ? m_opaque_sp->GetPrompt() : "")); 1012254721Semaste 1013254721Semaste if (m_opaque_sp) 1014254721Semaste return m_opaque_sp->GetPrompt (); 1015254721Semaste return 0; 1016254721Semaste} 1017254721Semaste 1018254721Semastevoid 1019254721SemasteSBDebugger::SetPrompt (const char *prompt) 1020254721Semaste{ 1021254721Semaste if (m_opaque_sp) 1022254721Semaste m_opaque_sp->SetPrompt (prompt); 1023254721Semaste} 1024254721Semaste 1025254721Semaste 1026254721SemasteScriptLanguage 1027254721SemasteSBDebugger::GetScriptLanguage() const 1028254721Semaste{ 1029254721Semaste if (m_opaque_sp) 1030254721Semaste return m_opaque_sp->GetScriptLanguage (); 1031254721Semaste return eScriptLanguageNone; 1032254721Semaste} 1033254721Semaste 1034254721Semastevoid 1035254721SemasteSBDebugger::SetScriptLanguage (ScriptLanguage script_lang) 1036254721Semaste{ 1037254721Semaste if (m_opaque_sp) 1038254721Semaste { 1039254721Semaste m_opaque_sp->SetScriptLanguage (script_lang); 1040254721Semaste } 1041254721Semaste} 1042254721Semaste 1043254721Semastebool 1044254721SemasteSBDebugger::SetUseExternalEditor (bool value) 1045254721Semaste{ 1046254721Semaste if (m_opaque_sp) 1047254721Semaste return m_opaque_sp->SetUseExternalEditor (value); 1048254721Semaste return false; 1049254721Semaste} 1050254721Semaste 1051254721Semastebool 1052254721SemasteSBDebugger::GetUseExternalEditor () 1053254721Semaste{ 1054254721Semaste if (m_opaque_sp) 1055254721Semaste return m_opaque_sp->GetUseExternalEditor (); 1056254721Semaste return false; 1057254721Semaste} 1058254721Semaste 1059254721Semastebool 1060254721SemasteSBDebugger::SetUseColor (bool value) 1061254721Semaste{ 1062254721Semaste if (m_opaque_sp) 1063254721Semaste return m_opaque_sp->SetUseColor (value); 1064254721Semaste return false; 1065254721Semaste} 1066254721Semaste 1067254721Semastebool 1068254721SemasteSBDebugger::GetUseColor () const 1069254721Semaste{ 1070254721Semaste if (m_opaque_sp) 1071254721Semaste return m_opaque_sp->GetUseColor (); 1072254721Semaste return false; 1073254721Semaste} 1074254721Semaste 1075254721Semastebool 1076254721SemasteSBDebugger::GetDescription (SBStream &description) 1077254721Semaste{ 1078254721Semaste Stream &strm = description.ref(); 1079254721Semaste 1080254721Semaste if (m_opaque_sp) 1081254721Semaste { 1082254721Semaste const char *name = m_opaque_sp->GetInstanceName().AsCString(); 1083254721Semaste user_id_t id = m_opaque_sp->GetID(); 1084254721Semaste strm.Printf ("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id); 1085254721Semaste } 1086254721Semaste else 1087254721Semaste strm.PutCString ("No value"); 1088254721Semaste 1089254721Semaste return true; 1090254721Semaste} 1091254721Semaste 1092254721Semasteuser_id_t 1093254721SemasteSBDebugger::GetID() 1094254721Semaste{ 1095254721Semaste if (m_opaque_sp) 1096254721Semaste return m_opaque_sp->GetID(); 1097254721Semaste return LLDB_INVALID_UID; 1098254721Semaste} 1099254721Semaste 1100254721Semaste 1101254721SemasteSBError 1102254721SemasteSBDebugger::SetCurrentPlatform (const char *platform_name) 1103254721Semaste{ 1104254721Semaste SBError sb_error; 1105254721Semaste if (m_opaque_sp) 1106254721Semaste { 1107254721Semaste PlatformSP platform_sp (Platform::Create (platform_name, sb_error.ref())); 1108254721Semaste 1109254721Semaste if (platform_sp) 1110254721Semaste { 1111254721Semaste bool make_selected = true; 1112254721Semaste m_opaque_sp->GetPlatformList().Append (platform_sp, make_selected); 1113254721Semaste } 1114254721Semaste } 1115254721Semaste return sb_error; 1116254721Semaste} 1117254721Semaste 1118254721Semastebool 1119254721SemasteSBDebugger::SetCurrentPlatformSDKRoot (const char *sysroot) 1120254721Semaste{ 1121254721Semaste if (m_opaque_sp) 1122254721Semaste { 1123254721Semaste PlatformSP platform_sp (m_opaque_sp->GetPlatformList().GetSelectedPlatform()); 1124254721Semaste 1125254721Semaste if (platform_sp) 1126254721Semaste { 1127254721Semaste platform_sp->SetSDKRootDirectory (ConstString (sysroot)); 1128254721Semaste return true; 1129254721Semaste } 1130254721Semaste } 1131254721Semaste return false; 1132254721Semaste} 1133254721Semaste 1134254721Semastebool 1135254721SemasteSBDebugger::GetCloseInputOnEOF () const 1136254721Semaste{ 1137254721Semaste if (m_opaque_sp) 1138254721Semaste return m_opaque_sp->GetCloseInputOnEOF (); 1139254721Semaste return false; 1140254721Semaste} 1141254721Semaste 1142254721Semastevoid 1143254721SemasteSBDebugger::SetCloseInputOnEOF (bool b) 1144254721Semaste{ 1145254721Semaste if (m_opaque_sp) 1146254721Semaste m_opaque_sp->SetCloseInputOnEOF (b); 1147254721Semaste} 1148254721Semaste 1149254721SemasteSBTypeCategory 1150254721SemasteSBDebugger::GetCategory (const char* category_name) 1151254721Semaste{ 1152254721Semaste if (!category_name || *category_name == 0) 1153254721Semaste return SBTypeCategory(); 1154254721Semaste 1155254721Semaste TypeCategoryImplSP category_sp; 1156254721Semaste 1157254721Semaste if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false)) 1158254721Semaste return SBTypeCategory(category_sp); 1159254721Semaste else 1160254721Semaste return SBTypeCategory(); 1161254721Semaste} 1162254721Semaste 1163254721SemasteSBTypeCategory 1164254721SemasteSBDebugger::CreateCategory (const char* category_name) 1165254721Semaste{ 1166254721Semaste if (!category_name || *category_name == 0) 1167254721Semaste return SBTypeCategory(); 1168254721Semaste 1169254721Semaste TypeCategoryImplSP category_sp; 1170254721Semaste 1171254721Semaste if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true)) 1172254721Semaste return SBTypeCategory(category_sp); 1173254721Semaste else 1174254721Semaste return SBTypeCategory(); 1175254721Semaste} 1176254721Semaste 1177254721Semastebool 1178254721SemasteSBDebugger::DeleteCategory (const char* category_name) 1179254721Semaste{ 1180254721Semaste if (!category_name || *category_name == 0) 1181254721Semaste return false; 1182254721Semaste 1183254721Semaste return DataVisualization::Categories::Delete(ConstString(category_name)); 1184254721Semaste} 1185254721Semaste 1186254721Semasteuint32_t 1187254721SemasteSBDebugger::GetNumCategories() 1188254721Semaste{ 1189254721Semaste return DataVisualization::Categories::GetCount(); 1190254721Semaste} 1191254721Semaste 1192254721SemasteSBTypeCategory 1193254721SemasteSBDebugger::GetCategoryAtIndex (uint32_t index) 1194254721Semaste{ 1195254721Semaste return SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)); 1196254721Semaste} 1197254721Semaste 1198254721SemasteSBTypeCategory 1199254721SemasteSBDebugger::GetDefaultCategory() 1200254721Semaste{ 1201254721Semaste return GetCategory("default"); 1202254721Semaste} 1203254721Semaste 1204254721SemasteSBTypeFormat 1205254721SemasteSBDebugger::GetFormatForType (SBTypeNameSpecifier type_name) 1206254721Semaste{ 1207254721Semaste SBTypeCategory default_category_sb = GetDefaultCategory(); 1208254721Semaste if (default_category_sb.GetEnabled()) 1209254721Semaste return default_category_sb.GetFormatForType(type_name); 1210254721Semaste return SBTypeFormat(); 1211254721Semaste} 1212254721Semaste 1213254721Semaste#ifndef LLDB_DISABLE_PYTHON 1214254721SemasteSBTypeSummary 1215254721SemasteSBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name) 1216254721Semaste{ 1217254721Semaste if (type_name.IsValid() == false) 1218254721Semaste return SBTypeSummary(); 1219254721Semaste return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())); 1220254721Semaste} 1221254721Semaste#endif // LLDB_DISABLE_PYTHON 1222254721Semaste 1223254721SemasteSBTypeFilter 1224254721SemasteSBDebugger::GetFilterForType (SBTypeNameSpecifier type_name) 1225254721Semaste{ 1226254721Semaste if (type_name.IsValid() == false) 1227254721Semaste return SBTypeFilter(); 1228254721Semaste return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())); 1229254721Semaste} 1230254721Semaste 1231254721Semaste#ifndef LLDB_DISABLE_PYTHON 1232254721SemasteSBTypeSynthetic 1233254721SemasteSBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name) 1234254721Semaste{ 1235254721Semaste if (type_name.IsValid() == false) 1236254721Semaste return SBTypeSynthetic(); 1237254721Semaste return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP())); 1238254721Semaste} 1239254721Semaste#endif // LLDB_DISABLE_PYTHON 1240254721Semaste 1241254721Semastebool 1242254721SemasteSBDebugger::EnableLog (const char *channel, const char **categories) 1243254721Semaste{ 1244254721Semaste if (m_opaque_sp) 1245254721Semaste { 1246254721Semaste uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 1247254721Semaste StreamString errors; 1248254721Semaste return m_opaque_sp->EnableLog (channel, categories, NULL, log_options, errors); 1249254721Semaste 1250254721Semaste } 1251254721Semaste else 1252254721Semaste return false; 1253254721Semaste} 1254254721Semaste 1255254721Semastevoid 1256254721SemasteSBDebugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton) 1257254721Semaste{ 1258254721Semaste if (m_opaque_sp) 1259254721Semaste { 1260254721Semaste return m_opaque_sp->SetLoggingCallback (log_callback, baton); 1261254721Semaste } 1262254721Semaste} 1263254721Semaste 1264254721Semaste 1265