ExecutionContext &exe_ctx, DiagnosticManager &diagnostic_manager) {
Process *process = exe_ctx.GetProcessPtr();
- if (!process)
+ if (!process) {
+ diagnostic_manager.Printf(eDiagnosticSeverityError, "no process.");
return false;
-
+ }
+
lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
- if (process != jit_process_sp.get())
+ if (process != jit_process_sp.get()) {
+ diagnostic_manager.Printf(eDiagnosticSeverityError,
+ "process does not match the stored process.");
return false;
-
- if (!m_compiled)
+ }
+
+ if (process->GetState() != lldb::eStateStopped) {
+ diagnostic_manager.Printf(eDiagnosticSeverityError,
+ "process is not stopped");
return false;
+ }
+ if (!m_compiled) {
+ diagnostic_manager.Printf(eDiagnosticSeverityError,
+ "function not compiled");
+ return false;
+ }
+
if (m_JITted)
return true;
bool FunctionCaller::InsertFunction(ExecutionContext &exe_ctx,
lldb::addr_t &args_addr_ref,
DiagnosticManager &diagnostic_manager) {
+ // Since we might need to call allocate memory and maybe call code to make
+ // the caller, we need to be stopped.
+ Process *process = exe_ctx.GetProcessPtr();
+ if (!process) {
+ diagnostic_manager.PutString(eDiagnosticSeverityError, "no process");
+ return false;
+ }
+ if (process->GetState() != lldb::eStateStopped) {
+ diagnostic_manager.PutString(eDiagnosticSeverityError, "process running");
+ return false;
+ }
if (CompileFunction(exe_ctx.GetThreadSP(), diagnostic_manager) != 0)
return false;
if (!WriteFunctionWrapper(exe_ctx, diagnostic_manager))
Process *process = exe_ctx.GetProcessPtr();
- if (process == nullptr || process->GetState() != lldb::eStateStopped) {
- if (execution_policy == eExecutionPolicyAlways) {
- LLDB_LOG(log, "== [UserExpression::Evaluate] Expression may not run, but "
- "is not constant ==");
+ if (process == nullptr && execution_policy == eExecutionPolicyAlways) {
+ LLDB_LOG(log, "== [UserExpression::Evaluate] No process, but the policy is "
+ "eExecutionPolicyAlways");
- error.SetErrorString("expression needed to run but couldn't");
+ error.SetErrorString("expression needed to run but couldn't: no process");
- return execution_results;
- }
+ return execution_results;
}
+ // Since we might need to call allocate memory and maybe call code to make
+ // the caller, we need to be stopped.
+ if (process != nullptr && process->GetState() != lldb::eStateStopped) {
+ error.SetErrorString("Can't make a function caller while the process is "
+ "running");
+ return execution_results;
+ }
+
// Explicitly force the IR interpreter to evaluate the expression when the
// there is no process that supports running the expression for us. Don't
error.SetErrorString("Can't make a function caller without a process.");
return nullptr;
}
+ // Since we might need to call allocate memory and maybe call code to make
+ // the caller, we need to be stopped.
+ if (process_sp->GetState() != lldb::eStateStopped) {
+ error.SetErrorString("Can't make a function caller while the process is "
+ "running");
+ return nullptr;
+ }
Address impl_code_address;
impl_code_address.SetOffset(StartAddress());
return false;
}
+ // Since we might need to call allocate memory and maybe call code to make
+ // the caller, we need to be stopped.
+ if (process->GetState() != lldb::eStateStopped) {
+ diagnostic_manager.PutString(eDiagnosticSeverityError, "process running");
+ return false;
+ }
//////////////////////////
// Parse the expression
//
}
StateType Process::GetState() {
- return m_public_state.GetValue();
+ if (CurrentThreadIsPrivateStateThread())
+ return m_private_state.GetValue();
+ else
+ return m_public_state.GetValue();
}
void Process::SetPublicState(StateType new_state, bool restarted) {