61 : m_opaque_wp(process_sp) {
79 return Process::GetStaticBroadcasterClass().AsCString();
85 ProcessSP process_sp(
GetSP());
95 ProcessSP process_sp(
GetSP());
114 return this->
operator bool();
116 SBProcess::operator bool()
const {
119 ProcessSP process_sp(m_opaque_wp.lock());
120 return ((
bool)process_sp && process_sp->IsValid());
124 const char *stdin_path,
const char *stdout_path,
125 const char *stderr_path,
126 const char *working_directory,
127 uint32_t launch_flags,
bool stop_at_entry,
130 working_directory, launch_flags, stop_at_entry,
error);
132 ProcessSP process_sp(
GetSP());
134 std::lock_guard<std::recursive_mutex> guard(
135 process_sp->GetTarget().GetAPIMutex());
138 launch_flags |= eLaunchFlagStopAtEntry;
141 FileSpec(working_directory), launch_flags);
142 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
149 error.SetError(process_sp->Launch(launch_info));
151 error.SetErrorString(
"must be in eStateConnected to call RemoteLaunch");
154 error.SetErrorString(
"unable to attach pid");
157 return error.Success();
164 ProcessSP process_sp(
GetSP());
166 std::lock_guard<std::recursive_mutex> guard(
167 process_sp->GetTarget().GetAPIMutex());
171 error.SetError(process_sp->Attach(attach_info));
173 error.SetErrorString(
174 "must be in eStateConnected to call RemoteAttachToProcessWithID");
177 error.SetErrorString(
"unable to attach pid");
180 return error.Success();
187 ProcessSP process_sp(
GetSP());
191 const bool can_update = stop_locker.
TryLock(&process_sp->GetRunLock());
192 std::lock_guard<std::recursive_mutex> guard(
193 process_sp->GetTarget().GetAPIMutex());
194 num_threads = process_sp->GetThreadList().GetSize(can_update);
205 ProcessSP process_sp(
GetSP());
207 std::lock_guard<std::recursive_mutex> guard(
208 process_sp->GetTarget().GetAPIMutex());
209 thread_sp = process_sp->GetThreadList().GetSelectedThread();
222 ProcessSP process_sp(
GetSP());
224 std::lock_guard<std::recursive_mutex> guard(
225 process_sp->GetTarget().GetAPIMutex());
226 thread_sp = process_sp->CreateOSPluginThread(tid, context);
238 ProcessSP process_sp(
GetSP());
240 target_sp = process_sp->GetTarget().shared_from_this();
241 sb_target.
SetSP(target_sp);
251 ProcessSP process_sp(
GetSP());
254 ret_val = process_sp->PutSTDIN(src, src_len,
error);
263 size_t bytes_read = 0;
264 ProcessSP process_sp(
GetSP());
267 bytes_read = process_sp->GetSTDOUT(dst, dst_len,
error);
276 size_t bytes_read = 0;
277 ProcessSP process_sp(
GetSP());
280 bytes_read = process_sp->GetSTDERR(dst, dst_len,
error);
289 size_t bytes_read = 0;
290 ProcessSP process_sp(
GetSP());
293 bytes_read = process_sp->GetAsyncProfileData(dst, dst_len,
error);
307 FileSP outfile = std::make_shared<NativeFile>(out,
false);
315 if (!out || !out->IsValid())
318 ProcessSP process_sp(
GetSP());
322 stream.
Printf(
"Process %" PRIu64
" %s\n",
331 ProcessSP process_sp(
GetSP());
345 ProcessSP process_sp(
GetSP());
347 std::lock_guard<std::recursive_mutex> guard(
348 process_sp->GetTarget().GetAPIMutex());
349 return process_sp->GetThreadList().SetSelectedThreadByID(
358 bool ret_val =
false;
359 ProcessSP process_sp(
GetSP());
361 std::lock_guard<std::recursive_mutex> guard(
362 process_sp->GetTarget().GetAPIMutex());
363 ret_val = process_sp->GetThreadList().SetSelectedThreadByID(tid);
372 bool ret_val =
false;
373 ProcessSP process_sp(
GetSP());
375 std::lock_guard<std::recursive_mutex> guard(
376 process_sp->GetTarget().GetAPIMutex());
377 ret_val = process_sp->GetThreadList().SetSelectedThreadByIndexID(index_id);
389 ProcessSP process_sp(
GetSP());
392 const bool can_update = stop_locker.
TryLock(&process_sp->GetRunLock());
393 std::lock_guard<std::recursive_mutex> guard(
394 process_sp->GetTarget().GetAPIMutex());
395 thread_sp = process_sp->GetThreadList().GetThreadAtIndex(index, can_update);
406 ProcessSP process_sp(
GetSP());
409 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
410 std::lock_guard<std::recursive_mutex> guard(
411 process_sp->GetTarget().GetAPIMutex());
412 num_queues = process_sp->GetQueueList().GetSize();
424 ProcessSP process_sp(
GetSP());
427 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
428 std::lock_guard<std::recursive_mutex> guard(
429 process_sp->GetTarget().GetAPIMutex());
430 queue_sp = process_sp->GetQueueList().GetQueueAtIndex(index);
441 ProcessSP process_sp(
GetSP());
443 std::lock_guard<std::recursive_mutex> guard(
444 process_sp->GetTarget().GetAPIMutex());
445 if (include_expression_stops)
446 return process_sp->GetStopID();
448 return process_sp->GetLastNaturalStopID();
458 ProcessSP process_sp(
GetSP());
460 std::lock_guard<std::recursive_mutex> guard(
461 process_sp->GetTarget().GetAPIMutex());
462 event_sp = process_sp->GetStopEventForStopID(stop_id);
463 sb_event.
reset(event_sp);
473 ProcessSP process_sp(
GetSP());
475 std::lock_guard<std::recursive_mutex> guard(
476 process_sp->GetTarget().GetAPIMutex());
477 ret_val = process_sp->GetState();
487 ProcessSP process_sp(
GetSP());
489 std::lock_guard<std::recursive_mutex> guard(
490 process_sp->GetTarget().GetAPIMutex());
491 exit_status = process_sp->GetExitStatus();
500 const char *exit_desc =
nullptr;
501 ProcessSP process_sp(
GetSP());
503 std::lock_guard<std::recursive_mutex> guard(
504 process_sp->GetTarget().GetAPIMutex());
505 exit_desc = process_sp->GetExitDescription();
514 ProcessSP process_sp(
GetSP());
516 ret_val = process_sp->GetID();
525 ProcessSP process_sp(
GetSP());
527 ret_val = process_sp->GetUniqueID();
535 ProcessSP process_sp(
GetSP());
537 byteOrder = process_sp->GetTarget().GetArchitecture().GetByteOrder();
547 ProcessSP process_sp(
GetSP());
549 size = process_sp->GetTarget().GetArchitecture().GetAddressByteSize();
559 ProcessSP process_sp(
GetSP());
562 std::lock_guard<std::recursive_mutex> guard(
563 process_sp->GetTarget().GetAPIMutex());
565 if (process_sp->GetTarget().GetDebugger().GetAsyncExecution())
566 sb_error.
ref() = process_sp->Resume();
568 sb_error.
ref() = process_sp->ResumeSynchronous(
nullptr);
579 ProcessSP process_sp(
GetSP());
581 std::lock_guard<std::recursive_mutex> guard(
582 process_sp->GetTarget().GetAPIMutex());
583 sb_error.
SetError(process_sp->Destroy(
false));
594 ProcessSP process_sp(
GetSP());
596 std::lock_guard<std::recursive_mutex> guard(
597 process_sp->GetTarget().GetAPIMutex());
598 sb_error.
SetError(process_sp->Halt());
609 ProcessSP process_sp(
GetSP());
611 std::lock_guard<std::recursive_mutex> guard(
612 process_sp->GetTarget().GetAPIMutex());
613 sb_error.
SetError(process_sp->Destroy(
true));
624 bool keep_stopped =
false;
625 return Detach(keep_stopped);
632 ProcessSP process_sp(
GetSP());
634 std::lock_guard<std::recursive_mutex> guard(
635 process_sp->GetTarget().GetAPIMutex());
636 sb_error.
SetError(process_sp->Detach(keep_stopped));
647 ProcessSP process_sp(
GetSP());
649 std::lock_guard<std::recursive_mutex> guard(
650 process_sp->GetTarget().GetAPIMutex());
651 sb_error.
SetError(process_sp->Signal(signo));
661 if (
auto process_sp =
GetSP())
670 ProcessSP process_sp(
GetSP());
672 process_sp->SendAsyncInterrupt();
681 ProcessSP process_sp(
GetSP());
684 const bool can_update = stop_locker.
TryLock(&process_sp->GetRunLock());
685 std::lock_guard<std::recursive_mutex> guard(
686 process_sp->GetTarget().GetAPIMutex());
687 thread_sp = process_sp->GetThreadList().FindThreadByID(tid, can_update);
699 ProcessSP process_sp(
GetSP());
702 const bool can_update = stop_locker.
TryLock(&process_sp->GetRunLock());
703 std::lock_guard<std::recursive_mutex> guard(
704 process_sp->GetTarget().GetAPIMutex());
706 process_sp->GetThreadList().FindThreadByIndexID(index_id, can_update);
716 StateType ret_val = Process::ProcessEventData::GetStateFromEvent(event.
get());
724 bool ret_val = Process::ProcessEventData::GetRestartedFromEvent(event.
get());
732 return Process::ProcessEventData::GetNumRestartedReasons(event.
get());
740 return Process::ProcessEventData::GetRestartedReasonAtIndex(event.
get(), idx);
746 ProcessSP process_sp =
747 Process::ProcessEventData::GetProcessFromEvent(event.
get());
750 process_sp = EventDataStructuredData::GetProcessFromEvent(event.
get());
759 return Process::ProcessEventData::GetInterruptedFromEvent(event.
get());
779 EventSP event_sp =
event.GetSP();
780 EventData *event_data = event_sp ? event_sp->GetData() :
nullptr;
781 return event_data && (event_data->
GetFlavor() ==
782 EventDataStructuredData::GetFlavorString());
788 ProcessSP process_sp(
GetSP());
798 return Process::GetStaticBroadcasterClass().AsCString();
805 size_t bytes_read = 0;
807 ProcessSP process_sp(
GetSP());
812 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
813 std::lock_guard<std::recursive_mutex> guard(
814 process_sp->GetTarget().GetAPIMutex());
815 bytes_read = process_sp->ReadMemory(addr, dst, dst_len, sb_error.
ref());
830 size_t bytes_read = 0;
831 ProcessSP process_sp(
GetSP());
834 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
835 std::lock_guard<std::recursive_mutex> guard(
836 process_sp->GetTarget().GetAPIMutex());
837 bytes_read = process_sp->ReadCStringFromMemory(addr, (
char *)buf, size,
853 ProcessSP process_sp(
GetSP());
856 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
857 std::lock_guard<std::recursive_mutex> guard(
858 process_sp->GetTarget().GetAPIMutex());
859 value = process_sp->ReadUnsignedIntegerFromMemory(addr, byte_size, 0,
875 ProcessSP process_sp(
GetSP());
878 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
879 std::lock_guard<std::recursive_mutex> guard(
880 process_sp->GetTarget().GetAPIMutex());
881 ptr = process_sp->ReadPointerFromMemory(addr, sb_error.
ref());
895 size_t bytes_written = 0;
897 ProcessSP process_sp(
GetSP());
901 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
902 std::lock_guard<std::recursive_mutex> guard(
903 process_sp->GetTarget().GetAPIMutex());
905 process_sp->WriteMemory(addr, src, src_len, sb_error.
ref());
911 return bytes_written;
919 ProcessSP process_sp(
GetSP());
923 Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
924 const char *exe_name =
nullptr;
928 strm.
Printf(
"SBProcess: pid = %" PRIu64
", state = %s, threads = %d%s%s",
931 exe_name ? exe_name :
"");
941 ProcessSP process_sp(
GetSP());
945 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
951 platform_sp->FetchExtendedCrashInformation(*process_sp.get());
957 data.
m_impl_up->SetObjectSP(fetched_data);
966 ProcessSP process_sp(
GetSP());
968 std::lock_guard<std::recursive_mutex> guard(
969 process_sp->GetTarget().GetAPIMutex());
970 sb_error.
SetError(process_sp->GetWatchpointSupportInfo(num));
989 ProcessSP process_sp(
GetSP());
992 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
993 std::lock_guard<std::recursive_mutex> guard(
994 process_sp->GetTarget().GetAPIMutex());
995 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
996 return platform_sp->LoadImage(process_sp.get(), *sb_local_image_spec,
997 *sb_remote_image_spec, sb_error.
ref());
1013 ProcessSP process_sp(
GetSP());
1016 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1017 std::lock_guard<std::recursive_mutex> guard(
1018 process_sp->GetTarget().GetAPIMutex());
1019 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
1020 size_t num_paths = paths.
GetSize();
1021 std::vector<std::string> paths_vec;
1022 paths_vec.reserve(num_paths);
1023 for (
size_t i = 0; i < num_paths; i++)
1027 uint32_t token = platform_sp->LoadImageUsingPaths(
1028 process_sp.get(), *image_spec, paths_vec,
error.ref(), &loaded_spec);
1030 loaded_path = loaded_spec;
1033 error.SetErrorString(
"process is running");
1036 error.SetErrorString(
"process is invalid");
1046 ProcessSP process_sp(
GetSP());
1049 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1050 std::lock_guard<std::recursive_mutex> guard(
1051 process_sp->GetTarget().GetAPIMutex());
1052 PlatformSP platform_sp = process_sp->GetTarget().GetPlatform();
1054 platform_sp->UnloadImage(process_sp.get(), image_token));
1067 ProcessSP process_sp(
GetSP());
1070 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1071 std::lock_guard<std::recursive_mutex> guard(
1072 process_sp->GetTarget().GetAPIMutex());
1073 sb_error.
SetError(process_sp->SendEventData(event_data));
1085 ProcessSP process_sp(
GetSP());
1086 if (process_sp && process_sp->GetSystemRuntime()) {
1096 ProcessSP process_sp(
GetSP());
1097 if (process_sp && process_sp->GetSystemRuntime()) {
1099 const std::vector<ConstString> &names =
1101 if (idx < names.size()) {
1102 return names[idx].AsCString();
1111 ProcessSP process_sp(
GetSP());
1123 ProcessSP process_sp(
GetSP());
1127 std::lock_guard<std::recursive_mutex> guard(
1128 process_sp->GetTarget().GetAPIMutex());
1130 InstrumentationRuntimeSP runtime_sp =
1131 process_sp->GetInstrumentationRuntime(type);
1133 if (!runtime_sp.get())
1136 return runtime_sp->IsActive();
1143 ProcessSP process_sp(
GetSP());
1145 error.SetErrorString(
"SBProcess is invalid");
1149 std::lock_guard<std::recursive_mutex> guard(
1150 process_sp->GetTarget().GetAPIMutex());
1153 error.SetErrorString(
"the process is not stopped");
1159 error.ref() = PluginManager::SaveCore(process_sp, core_file, core_style,
"");
1169 ProcessSP process_sp(
GetSP());
1172 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1173 std::lock_guard<std::recursive_mutex> guard(
1174 process_sp->GetTarget().GetAPIMutex());
1177 process_sp->GetMemoryRegionInfo(load_addr, sb_region_info.
ref());
1192 ProcessSP process_sp(
GetSP());
1194 if (process_sp && stop_locker.
TryLock(&process_sp->GetRunLock())) {
1195 std::lock_guard<std::recursive_mutex> guard(
1196 process_sp->GetTarget().GetAPIMutex());
1198 process_sp->GetMemoryRegions(sb_region_list.
ref());
1201 return sb_region_list;
1208 ProcessSP process_sp(
GetSP());
1210 if (process_sp && process_sp->GetProcessInfo(proc_info)) {
1213 return sb_proc_info;
1221 ProcessSP process_sp(
GetSP());
1224 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1225 std::lock_guard<std::recursive_mutex> guard(
1226 process_sp->GetTarget().GetAPIMutex());
1227 addr = process_sp->AllocateMemory(size, permissions, sb_error.
ref());
1241 ProcessSP process_sp(
GetSP());
1244 if (stop_locker.
TryLock(&process_sp->GetRunLock())) {
1245 std::lock_guard<std::recursive_mutex> guard(
1246 process_sp->GetTarget().GetAPIMutex());