+// C Includes

+// C++ Includes

+// Other libraries and framework includes

+// Project includes

+#include "lldb/Expression/UserExpression.h"

+#include "lldb/Host/FileSystem.h"

+#include "lldb/Symbol/Function.h"

+ const Property *

+ GetPropertyAtIndex(const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const override

+ { "optimization-warnings" , OptionValue::eTypeBoolean, false, true, NULL, NULL, "If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected." },

+ ePropertyMemCacheLineSize,

+ ePropertyWarningOptimization

+ProcessProperties::~ProcessProperties() = default;

+bool

+ProcessProperties::GetWarningsOptimization () const

+{

+ const uint32_t idx = ePropertyWarningOptimization;

+ return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);

+}

+

+ if (m_arch.IsValid())

+ {

+ s.Printf (" arch = ");

+ m_arch.DumpTriple(s);

+ s.EOL();

+ }

+ StreamString arch_strm;

+ if (m_arch.IsValid())

+ m_arch.DumpTriple(arch_strm);

+

+

+ s.Printf ("%-24s ", arch_strm.GetString().c_str());

+ arch_strm.GetString().c_str());

+ const FileSpec dev_null{FileSystem::DEV_NULL, false};

+Process::FindPlugin (lldb::TargetSP target_sp, const char *plugin_name, Listener &listener, const FileSpec *crash_file_path)

+ process_sp = create_callback(target_sp, listener, crash_file_path);

+ if (process_sp->CanDebug(target_sp, true))

+ process_sp = create_callback(target_sp, listener, crash_file_path);

+ if (process_sp->CanDebug(target_sp, false))

+Process::Process(lldb::TargetSP target_sp, Listener &listener) :

+ Process(target_sp, listener, UnixSignals::Create(HostInfo::GetArchitecture()))

+Process::Process(lldb::TargetSP target_sp, Listener &listener, const UnixSignalsSP &unix_signals_sp) :

+ Broadcaster (&(target_sp->GetDebugger()), Process::GetStaticBroadcasterClass().AsCString()),

+ m_target_sp (target_sp),

+ m_warnings_issued (),

+

+ // Allow the platform to override the default cache line size

+ OptionValueSP value_sp =

+ m_collection_sp->GetPropertyAtIndex(nullptr, true, ePropertyMemCacheLineSize)->GetValue();

+ uint32_t platform_cache_line_size = target_sp->GetPlatform()->GetDefaultMemoryCacheLineSize();

+ if (! value_sp->OptionWasSet() && platform_cache_line_size != 0)

+ value_sp->SetUInt64Value(platform_cache_line_size);

+ Stream *stream,

+ bool use_run_lock)

+ if (hijack_listener && use_run_lock)

+ if (hijack_listener && use_run_lock)

+ if (hijack_listener && use_run_lock)

+Process::WaitForState(const TimeValue *timeout,

+ const StateType *match_states,

+ const uint32_t num_match_states)

+ // When we exit, we don't need the input reader anymore

+bool

+Process::IsAlive ()

+{

+ switch (m_private_state.GetValue())

+ {

+ case eStateInvalid:

+ case eStateUnloaded:

+ case eStateDetached:

+ case eStateExited:

+ return false;

+

+ case eStateConnected:

+ case eStateAttaching:

+ case eStateLaunching:

+ case eStateStopped:

+ case eStateRunning:

+ case eStateStepping:

+ case eStateCrashed:

+ case eStateSuspended:

+ return true;

+ }

+}

+

+ OperatingSystem *os = GetOperatingSystem ();

+ if (os && !m_destroy_in_process)

+ // Clear any old backing threads where memory threads might have been

+ // backed by actual threads from the lldb_private::Process subclass

+ size_t num_old_threads = old_thread_list.GetSize(false);

+ for (size_t i=0; i<num_old_threads; ++i)

+ old_thread_list.GetThreadAtIndex(i, false)->ClearBackingThread();

+

+ // Turn off dynamic types to ensure we don't run any expressions. Objective C

+ // can run an expression to determine if a SBValue is a dynamic type or not

+ // and we need to avoid this. OperatingSystem plug-ins can't run expressions

+ // that require running code...

+

+ Target &target = GetTarget();

+ const lldb::DynamicValueType saved_prefer_dynamic = target.GetPreferDynamicValue ();

+ if (saved_prefer_dynamic != lldb::eNoDynamicValues)

+ target.SetPreferDynamicValue(lldb::eNoDynamicValues);

+

+ // Now let the OperatingSystem plug-in update the thread list

+

+ os->UpdateThreadList (old_thread_list, // Old list full of threads created by OS plug-in

+ real_thread_list, // The actual thread list full of threads created by each lldb_private::Process subclass

+ new_thread_list); // The new thread list that we will show to the user that gets filled in

+

+ if (saved_prefer_dynamic != lldb::eNoDynamicValues)

+ target.SetPreferDynamicValue(saved_prefer_dynamic);

+ }

+ else

+ {

+ // No OS plug-in, the new thread list is the same as the real thread list

+ new_thread_list = real_thread_list;

+ return (m_thread_id_to_index_id_map.find(thread_id) != m_thread_id_to_index_id_map.end());

+ m_abi_sp = ABI::FindPlugin(GetTarget().GetArchitecture());

+ GetTarget().GetDebugger().GetErrorFile()->Printf ("warning: failed to resolve indirect function at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",

+ symbol->GetLoadAddress(&GetTarget()),

+ owner->GetBreakpoint().GetID(),

+ owner->GetID(),

+ error.AsCString() ? error.AsCString() : "unknown error");

+ load_addr = resolved_address.GetOpcodeLoadAddress (&GetTarget());

+ load_addr = owner->GetAddress().GetOpcodeLoadAddress (&GetTarget());

+ load_addr = owner->GetAddress().GetOpcodeLoadAddress (&GetTarget());

+ GetTarget().GetDebugger().GetErrorFile()->Printf ("warning: failed to set breakpoint site at 0x%" PRIx64 " for breakpoint %i.%i: %s\n",

+ load_addr,

+ owner->GetBreakpoint().GetID(),

+ owner->GetID(),

+ error.AsCString() ? error.AsCString() : "unknown error");

+ PlatformSP platform_sp (GetTarget().GetPlatform());

+ return platform_sp->GetSoftwareBreakpointTrapOpcode (GetTarget(), bp_site);

+ UNUSED_IF_ASSERT_DISABLED(intersects);

+addr_t

+Process::CallocateMemory(size_t size, uint32_t permissions, Error &error)

+{

+ addr_t return_addr = AllocateMemory(size, permissions, error);

+ if (error.Success())

+ {

+ std::string buffer(size, 0);

+ WriteMemory(return_addr, buffer.c_str(), size, error);

+ }

+ return return_addr;

+}

+

+ Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST);

+ if (log)

+ {

+ log->Printf ("Process::ReadModuleFromMemory reading %s binary from memory", file_spec.GetPath().c_str());

+ }

+ Module *exe_module = GetTarget().GetExecutableModulePointer();

+ PlatformSP platform_sp (GetTarget().GetPlatform ());

+ GetTarget().SetArchitecture(process_arch);

+ PlatformSP platform_sp (GetTarget().GetPlatform ());

+ const ArchSpec &target_arch = GetTarget().GetArchitecture();

+ GetTarget().SetPlatform (platform_sp);

+ GetTarget().SetArchitecture(platform_arch);

+ if (process_arch.IsValid() && !GetTarget().GetArchitecture().IsExactMatch(process_arch))

+ GetTarget().SetArchitecture (process_arch);

+ ModuleSP exe_module_sp = GetTarget().GetExecutableModule ();

+ ModuleSP exe_module_sp = GetTarget().GetExecutableModule ();

+ const ModuleList &target_modules = GetTarget().GetImages();

+ if (GetTarget().GetExecutableModulePointer() != module_sp.get())

+ GetTarget().SetExecutableModule (new_executable_module_sp, false);

+ ModuleSP exe_module_sp = GetTarget().GetExecutableModule ();

+Process::Halt (bool clear_thread_plans, bool use_run_lock)

+ if (! StateIsRunningState(m_public_state.GetValue()))

+ return Error("Process is not running.");

+

+ HijackProcessEvents(&halt_listener);

+ SendAsyncInterrupt();

+

+ if (m_public_state.GetValue() == eStateAttaching)

+ // Don't hijack and eat the eStateExited as the code that was doing

+ // the attach will be waiting for this event...

+ RestoreProcessEvents();

+ SetExitStatus(SIGKILL, "Cancelled async attach.");

+ Destroy (false);

+ return Error();

+ // Wait for 10 second for the process to stop.

+ TimeValue timeout_time;

+ timeout_time = TimeValue::Now();

+ timeout_time.OffsetWithSeconds(10);

+ StateType state = WaitForProcessToStop(&timeout_time, &event_sp, true, &halt_listener,

+ nullptr, use_run_lock);

+ RestoreProcessEvents();

+ if (state == eStateInvalid || ! event_sp)

+ {

+ // We timed out and didn't get a stop event...

+ return Error("Halt timed out. State = %s", StateAsCString(GetState()));

+ }

+

+ BroadcastEvent(event_sp);

+

+ return Error();

+Process::StopForDestroyOrDetach(lldb::EventSP &exit_event_sp)

+ log->Printf("Process::%s() About to stop.", __FUNCTION__);

+

+ ListenerSP listener_sp (new Listener("lldb.Process.StopForDestroyOrDetach.hijack"));

+ HijackProcessEvents(listener_sp.get());

+

+ SendAsyncInterrupt();

+

+ // Consume the interrupt event.

+ TimeValue timeout (TimeValue::Now());

+ timeout.OffsetWithSeconds(10);

+

+ StateType state = WaitForProcessToStop (&timeout, &exit_event_sp, true, listener_sp.get());

+

+ RestoreProcessEvents();

+

+ // If the process exited while we were waiting for it to stop, put the exited event into

+ // the shared pointer passed in and return. Our caller doesn't need to do anything else, since

+ // they don't have a process anymore...

+

+ if (state == eStateExited || m_private_state.GetValue() == eStateExited)

+ if (log)

+ log->Printf("Process::%s() Process exited while waiting to stop.", __FUNCTION__);

+ return error;

+ exit_event_sp.reset(); // It is ok to consume any non-exit stop events

+

+ if (state != eStateStopped)

+ log->Printf("Process::%s() failed to stop, state is: %s", __FUNCTION__, StateAsCString(state));

+ // If we really couldn't stop the process then we should just error out here, but if the

+ // lower levels just bobbled sending the event and we really are stopped, then continue on.

+ StateType private_state = m_private_state.GetValue();

+ if (private_state != eStateStopped)

+ {

+ return error;

+ }

+ error = StopForDestroyOrDetach (exit_event_sp);

+

+ error = StopForDestroyOrDetach(exit_event_sp);

+Process::SetUnixSignals(UnixSignalsSP &&signals_sp)

+ return GetTarget().GetArchitecture().GetByteOrder();

+ return GetTarget().GetArchitecture().GetAddressByteSize();

+ m_stdio_communication.Disconnect();

+ m_stdio_communication.StopReadThread();

+ m_stdin_forward = false;

+

+ log->Printf ("Process::ShouldBroadcastEvent: should_resume: %i state: %s was_restarted: %i stop_vote: %d.",

+ m_private_state_thread = ThreadLauncher::LaunchThread(thread_name, Process::PrivateStateThread, (void *) &args, NULL, 8 * 1024 * 1024);

+ if (is_hijacked || GetTarget().GetDebugger().IsHandlingEvents() == false)

+}

+

+Error

+Process::HaltPrivate()

+{

+ EventSP event_sp;

+ Error error (WillHalt());

+ if (error.Fail())

+ return error;

+

+ // Ask the process subclass to actually halt our process

+ bool caused_stop;

+ error = DoHalt(caused_stop);

+

+ DidHalt();

+ return error;

+ bool interrupt_requested = false;

+ else if(StateIsRunningState(m_last_broadcast_state))

+ Error error = HaltPrivate();

+ if (error.Fail() && log)

+ log->Printf ("Process::%s (arg = %p, pid = %" PRIu64 ") failed to halt the process: %s",

+ __FUNCTION__, static_cast<void*>(this),

+ GetID(), error.AsCString());

+ // Halt should generate a stopped event. Make a note of the fact that we were

+ // doing the interrupt, so we can set the interrupted flag after we receive the

+ // event. We deliberately set this to true even if HaltPrivate failed, so that we

+ // can interrupt on the next natural stop.

+ interrupt_requested = true;

+ }

+ else

+ {

+ // This can happen when someone (e.g. Process::Halt) sees that we are running and

+ // sends an interrupt request, but the process actually stops before we receive

+ // it. In that case, we can just ignore the request. We use

+ // m_last_broadcast_state, because the Stopped event may not have been popped of

+ // the event queue yet, which is when the public state gets updated.

+ if (log)

+ log->Printf("Process::%s ignoring interrupt as we have already stopped.", __FUNCTION__);

+

+ if (interrupt_requested)

+ {

+ if (StateIsStoppedState (internal_state, true))

+ {

+ // We requested the interrupt, so mark this as such in the stop event so

+ // clients can tell an interrupted process from a natural stop

+ ProcessEventData::SetInterruptedInEvent (event_sp.get(), true);

+ interrupt_requested = false;

+ }

+ else if (log)

+ {

+ log->Printf("Process::%s interrupt_requested, but a non-stopped state '%s' received.",

+ __FUNCTION__, StateAsCString(internal_state));

+ }

+ }

+

+Process::ProcessEventData::~ProcessEventData() = default;

+ {

+ // Let process subclasses know we are about to do a public stop and

+ // do anything they might need to in order to speed up register and

+ // memory accesses.

+ process_sp->WillPublicStop();

+

+ return m_target_sp.lock();

+ exe_ctx.SetTargetPtr (&GetTarget());

+ ~IOHandlerProcessSTDIO() override = default;

+

+ m_process->SendAsyncInterrupt();

+ // that was written to the pipe and then call m_process->SendAsyncInterrupt()

+ // from a much safer location in code.

+ return GetTarget().GetDebugger().IsTopIOHandler (io_handler_sp);

+ GetTarget().GetDebugger().PushIOHandler (io_handler_sp);

+ return GetTarget().GetDebugger().PopIOHandler (io_handler_sp);

+namespace

+{

+ // RestorePlanState is used to record the "is private", "is master" and "okay to discard" fields of

+ // the plan we are running, and reset it on Clean or on destruction.

+ // It will only reset the state once, so you can call Clean and then monkey with the state and it

+ // won't get reset on you again.

+

+ class RestorePlanState

+ {

+ public:

+ RestorePlanState (lldb::ThreadPlanSP thread_plan_sp) :

+ m_thread_plan_sp(thread_plan_sp),

+ m_already_reset(false)

+ {

+ if (m_thread_plan_sp)

+ {

+ m_private = m_thread_plan_sp->GetPrivate();

+ m_is_master = m_thread_plan_sp->IsMasterPlan();

+ m_okay_to_discard = m_thread_plan_sp->OkayToDiscard();

+ }

+ }

+

+ ~RestorePlanState()

+ {

+ Clean();

+ }

+

+ void

+ Clean ()

+ {

+ if (!m_already_reset && m_thread_plan_sp)

+ {

+ m_already_reset = true;

+ m_thread_plan_sp->SetPrivate(m_private);

+ m_thread_plan_sp->SetIsMasterPlan (m_is_master);

+ m_thread_plan_sp->SetOkayToDiscard(m_okay_to_discard);

+ }

+ }

+

+ private:

+ lldb::ThreadPlanSP m_thread_plan_sp;

+ bool m_already_reset;

+ bool m_private;

+ bool m_is_master;

+ bool m_okay_to_discard;

+ };

+} // anonymous namespace

+

+ // We need to change some of the thread plan attributes for the thread plan runner. This will restore them

+ // when we are done:

+

+ RestorePlanState thread_plan_restorer(thread_plan_sp);

+

+

+ // The plans run with RunThreadPlan also need to be terminal master plans or when they are done we will end

+ // up asking the plan above us whether we should stop, which may give the wrong answer.

+

+ thread_plan_sp->SetIsMasterPlan (true);

+ thread_plan_sp->SetOkayToDiscard(false);

+

+ const bool clear_thread_plans = false;

+ const bool use_run_lock = false;

+ Halt(clear_thread_plans, use_run_lock);

+ const bool clear_thread_plans = false;

+ const bool use_run_lock = false;

+ Halt(clear_thread_plans, use_run_lock);

+

+ // Restore the plan state so it will get reported as intended when we are done.

+ thread_plan_restorer.Clean();

+

+ // Restore the plan state and then force Private to false. We are

+ // going to stop because of this plan so we need it to become a public

+ // plan or it won't report correctly when we continue to its termination

+ // later on.

+ thread_plan_restorer.Clean();

+ if (thread_plan_sp)

+ thread_plan_sp->SetPrivate(false);

+ const bool clear_thread_plans = false;

+ const bool use_run_lock = false;

+ Halt(clear_thread_plans, use_run_lock);

+ if (return_value != eExpressionCompleted && log)

+ {

+ // Print a backtrace into the log so we can figure out where we are:

+ StreamString s;

+ s.PutCString("Thread state after unsuccessful completion: \n");

+ thread->GetStackFrameStatus (s,

+ 0,

+ UINT32_MAX,

+ true,

+ UINT32_MAX);

+ log->PutCString(s.GetData());

+

+ }

+ // Show the private stop info here, the public stop info will be from the last natural stop.

+ lldb::StopInfoSP stop_info_sp = thread->GetPrivateStopInfo();

+

+ LoadOperatingSystemPlugin(false);

+}

+

+void

+Process::PrintWarning (uint64_t warning_type, const void *repeat_key, const char *fmt, ...)

+{

+ bool print_warning = true;

+

+ StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream();

+ if (stream_sp.get() == nullptr)

+ return;

+ if (warning_type == eWarningsOptimization

+ && GetWarningsOptimization() == false)

+ {

+ return;

+ }

+

+ if (repeat_key != nullptr)

+ {

+ WarningsCollection::iterator it = m_warnings_issued.find (warning_type);

+ if (it == m_warnings_issued.end())

+ {

+ m_warnings_issued[warning_type] = WarningsPointerSet();

+ m_warnings_issued[warning_type].insert (repeat_key);

+ }

+ else

+ {

+ if (it->second.find (repeat_key) != it->second.end())

+ {

+ print_warning = false;

+ }

+ else

+ {

+ it->second.insert (repeat_key);

+ }

+ }

+ }

+

+ if (print_warning)

+ {

+ va_list args;

+ va_start (args, fmt);

+ stream_sp->PrintfVarArg (fmt, args);

+ va_end (args);

+ }

+}

+

+void

+Process::PrintWarningOptimization (const SymbolContext &sc)

+{

+ if (GetWarningsOptimization() == true

+ && sc.module_sp.get()

+ && sc.module_sp->GetFileSpec().GetFilename().IsEmpty() == false

+ && sc.function

+ && sc.function->GetIsOptimized() == true)

+ {

+ PrintWarning (Process::Warnings::eWarningsOptimization, sc.module_sp.get(), "%s was compiled with optimization - stepping may behave oddly; variables may not be available.\n", sc.module_sp->GetFileSpec().GetFilename().GetCString());

+ }

+

+size_t

+Process::AddImageToken(lldb::addr_t image_ptr)

+{

+ m_image_tokens.push_back(image_ptr);

+ return m_image_tokens.size() - 1;

+}

+

+lldb::addr_t

+Process::GetImagePtrFromToken(size_t token) const

+{

+ if (token < m_image_tokens.size())

+ return m_image_tokens[token];

+ return LLDB_INVALID_IMAGE_TOKEN;

+}

+

+void

+Process::ResetImageToken(size_t token)

+{

+ if (token < m_image_tokens.size())

+ m_image_tokens[token] = LLDB_INVALID_IMAGE_TOKEN;

+}