void GdbTermEngine::handleStubAttached(const DebuggerResponse &response)
{
// InferiorStopOk can happen if the "*stopped" in response to the
// 'attach' comes in before its '^done'
QTC_ASSERT(state() == EngineRunRequested || state() == InferiorStopOk,
qDebug() << state());
switch (response.resultClass) {
case ResultDone:
case ResultRunning:
if (runParameters().toolChainAbi.os() == ProjectExplorer::Abi::WindowsOS) {
QString errorMessage;
// Resume thread that was suspended by console stub process (see stub code).
const qint64 mainThreadId = m_stubProc.applicationMainThreadID();
if (winResumeThread(mainThreadId, &errorMessage)) {
showMessage(QString::fromLatin1("Inferior attached, thread %1 resumed").
arg(mainThreadId), LogMisc);
} else {
showMessage(QString::fromLatin1("Inferior attached, unable to resume thread %1: %2").
arg(mainThreadId).arg(errorMessage),
LogWarning);
}
notifyEngineRunAndInferiorStopOk();
continueInferiorInternal();
} else {
showMessage(_("INFERIOR ATTACHED AND RUNNING"));
//notifyEngineRunAndInferiorRunOk();
// Wait for the upcoming *stopped and handle it there.
}
break;
case ResultError:
if (response.data["msg"].data() == "ptrace: Operation not permitted.") {
showMessage(msgPtraceError(runParameters().startMode));
notifyEngineRunFailed();
break;
}
showMessage(QString::fromLocal8Bit(response.data["msg"].data()));
notifyEngineIll();
break;
default:
showMessage(QString::fromLatin1("Invalid response %1").arg(response.resultClass));
notifyEngineIll();
break;
}
}
void GdbTermEngine::stubExited()
{
if (state() == EngineShutdownRequested || state() == DebuggerFinished) {
showMessage(_("STUB EXITED EXPECTEDLY"));
return;
}
showMessage(_("STUB EXITED"));
notifyEngineIll();
}
void GdbAttachEngine::handleAttach(const DebuggerResponse &response)
{
QTC_ASSERT(state() == EngineRunRequested || state() == InferiorStopOk,
qDebug() << state());
switch (response.resultClass) {
case ResultDone:
case ResultRunning:
showMessage(_("INFERIOR ATTACHED"));
if (state() == EngineRunRequested) {
// Happens e.g. for "Attach to unstarted application"
// We will get a '*stopped' later that we'll interpret as 'spontaneous'
// So acknowledge the current state and put a delayed 'continue' in the pipe.
showMessage(tr("Attached to running application"), StatusBar);
notifyEngineRunAndInferiorRunOk();
} else {
// InferiorStopOk, e.g. for "Attach to running application".
// The *stopped came in between sending the 'attach' and
// receiving its '^done'.
if (runParameters().continueAfterAttach)
continueInferiorInternal();
}
break;
case ResultError:
if (response.data["msg"].data() == "ptrace: Operation not permitted.") {
QString msg = msgPtraceError(runParameters().startMode);
showStatusMessage(tr("Failed to attach to application: %1").arg(msg));
Core::AsynchronousMessageBox::warning(tr("Debugger Error"), msg);
notifyEngineIll();
break;
}
// if msg != "ptrace: ..." fall through
default:
showStatusMessage(tr("Failed to attach to application: %1")
.arg(QString::fromLocal8Bit(response.data["msg"].data())));
notifyEngineIll();
}
}
void QmlCppEngine::continueInferior()
{
EDEBUG("\nMASTER CONTINUE INFERIOR"
<< state() << m_qmlEngine->state());
notifyInferiorRunRequested();
if (m_cppEngine->state() == InferiorStopOk) {
m_cppEngine->continueInferior();
} else if (m_qmlEngine->state() == InferiorStopOk) {
m_qmlEngine->continueInferior();
} else {
QTC_ASSERT(false, qDebug() << "MASTER CANNOT CONTINUE INFERIOR"
<< m_cppEngine->state() << m_qmlEngine->state());
notifyEngineIll();
}
}
void PdbEngine::postCommand(const QByteArray &command,
// PdbCommandFlags flags,
PdbCommandCallback callback,
const char *callbackName,
const QVariant &cookie)
{
QTC_ASSERT(m_pdbProc.state() == QProcess::Running, notifyEngineIll());
PdbCommand cmd;
cmd.command = command;
cmd.callback = callback;
cmd.callbackName = callbackName;
cmd.cookie = cookie;
m_commands.enqueue(cmd);
qDebug() << "ENQUEUE: " << command << cmd.callbackName;
showMessage(_(cmd.command), LogInput);
m_pdbProc.write(cmd.command + '\n');
}
void GdbCoreEngine::handleTargetCore(const DebuggerResponse &response)
{
CHECK_STATE(EngineRunRequested);
notifyEngineRunOkAndInferiorUnrunnable();
if (response.resultClass == ResultDone) {
showMessage(tr("Attached to core."), StatusBar);
// Due to the auto-solib-add off setting, we don't have any
// symbols yet. Load them in order of importance.
reloadStack();
reloadModulesInternal();
postCommand("p 5", NoFlags, CB(handleRoundTrip));
return;
}
showStatusMessage(tr("Attach to core \"%1\" failed:").arg(runParameters().coreFile)
+ QLatin1Char('\n') + QString::fromLocal8Bit(response.data["msg"].data()));
notifyEngineIll();
}
void IPCEngineHost::rpcCallback(quint64 f, QByteArray payload)
{
switch (f) {
default: {
showMessage(QLatin1String("IPC Error: unhandled id in guest to host call"));
const QString logMessage = tr("Fatal engine shutdown. Incompatible binary or IPC error.");
showMessage(logMessage, LogError);
showStatusMessage(logMessage);
}
nuke();
break;
case IPCEngineGuest::NotifyEngineSetupOk:
notifyEngineSetupOk();
break;
case IPCEngineGuest::NotifyEngineSetupFailed:
notifyEngineSetupFailed();
break;
case IPCEngineGuest::NotifyEngineRunFailed:
notifyEngineRunFailed();
break;
case IPCEngineGuest::NotifyInferiorSetupOk:
attemptBreakpointSynchronization();
notifyInferiorSetupOk();
break;
case IPCEngineGuest::NotifyInferiorSetupFailed:
notifyInferiorSetupFailed();
break;
case IPCEngineGuest::NotifyEngineRunAndInferiorRunOk:
notifyEngineRunAndInferiorRunOk();
break;
case IPCEngineGuest::NotifyEngineRunAndInferiorStopOk:
notifyEngineRunAndInferiorStopOk();
break;
case IPCEngineGuest::NotifyInferiorRunRequested:
notifyInferiorRunRequested();
break;
case IPCEngineGuest::NotifyInferiorRunOk:
notifyInferiorRunOk();
break;
case IPCEngineGuest::NotifyInferiorRunFailed:
notifyInferiorRunFailed();
break;
case IPCEngineGuest::NotifyInferiorStopOk:
notifyInferiorStopOk();
break;
case IPCEngineGuest::NotifyInferiorSpontaneousStop:
notifyInferiorSpontaneousStop();
break;
case IPCEngineGuest::NotifyInferiorStopFailed:
notifyInferiorStopFailed();
break;
case IPCEngineGuest::NotifyInferiorExited:
notifyInferiorExited();
break;
case IPCEngineGuest::NotifyInferiorShutdownOk:
notifyInferiorShutdownOk();
break;
case IPCEngineGuest::NotifyInferiorShutdownFailed:
notifyInferiorShutdownFailed();
break;
case IPCEngineGuest::NotifyEngineSpontaneousShutdown:
notifyEngineSpontaneousShutdown();
break;
case IPCEngineGuest::NotifyEngineShutdownOk:
notifyEngineShutdownOk();
break;
case IPCEngineGuest::NotifyEngineShutdownFailed:
notifyEngineShutdownFailed();
break;
case IPCEngineGuest::NotifyInferiorIll:
notifyInferiorIll();
break;
case IPCEngineGuest::NotifyEngineIll:
notifyEngineIll();
break;
case IPCEngineGuest::NotifyInferiorPid:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
quint64 pid;
s >> pid;
notifyInferiorPid(pid);
}
break;
case IPCEngineGuest::ShowStatusMessage:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
QString msg;
qint64 timeout;
s >> msg;
s >> timeout;
showStatusMessage(msg, timeout);
}
break;
case IPCEngineGuest::ShowMessage:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
QString msg;
qint16 channel;
qint64 timeout;
s >> msg;
s >> channel;
s >> timeout;
showMessage(msg, channel, timeout);
}
break;
case IPCEngineGuest::CurrentFrameChanged:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
quint64 token;
s >> token;
resetLocation();
StackHandler *sh = stackHandler();
sh->setCurrentIndex(token);
if (!sh->currentFrame().isUsable() || QFileInfo(sh->currentFrame().file).exists())
gotoLocation(Location(sh->currentFrame(), true));
else if (!m_sourceAgents.contains(sh->currentFrame().file))
fetchFrameSource(token);
foreach(SourceAgent *agent, m_sourceAgents.values())
agent->updateLocationMarker();
}
break;
case IPCEngineGuest::CurrentThreadChanged:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
quint64 token;
s >> token;
threadsHandler()->setCurrentThreadId(token);
}
break;
case IPCEngineGuest::ListFrames:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
StackFrames frames;
s >> frames;
stackHandler()->setFrames(frames);
}
break;
case IPCEngineGuest::ListThreads:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
Threads threads;
s >> threads;
threadsHandler()->setThreads(threads);
}
break;
case IPCEngineGuest::Disassembled:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
quint64 pc;
DisassemblerLines lines;
s >> pc;
s >> lines;
DisassemblerAgent *view = m_frameToDisassemblerAgent.take(pc);
if (view)
view->setContents(lines);
}
break;
case IPCEngineGuest::UpdateWatchData:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
bool fullCycle;
qint64 count;
QList<WatchData> wd;
s >> fullCycle;
s >> count;
for (qint64 i = 0; i < count; ++i) {
WatchData d;
s >> d;
wd.append(d);
}
WatchHandler *wh = watchHandler();
if (!wh)
break;
wh->beginCycle(fullCycle);
wh->insertBulkData(wd);
wh->endCycle(fullCycle);
}
break;
case IPCEngineGuest::NotifyAddBreakpointOk:
{
attemptBreakpointSynchronization();
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
BreakpointId id;
s >> id;
breakHandler()->notifyBreakpointInsertOk(id);
}
break;
case IPCEngineGuest::NotifyAddBreakpointFailed:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
BreakpointId id;
s >> id;
breakHandler()->notifyBreakpointInsertFailed(id);
}
break;
case IPCEngineGuest::NotifyRemoveBreakpointOk:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
BreakpointId id;
s >> id;
breakHandler()->notifyBreakpointRemoveOk(id);
}
break;
case IPCEngineGuest::NotifyRemoveBreakpointFailed:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
BreakpointId id;
s >> id;
breakHandler()->notifyBreakpointRemoveFailed(id);
}
break;
case IPCEngineGuest::NotifyChangeBreakpointOk:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
BreakpointId id;
s >> id;
breakHandler()->notifyBreakpointChangeOk(id);
}
break;
case IPCEngineGuest::NotifyChangeBreakpointFailed:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
BreakpointId id;
s >> id;
breakHandler()->notifyBreakpointChangeFailed(id);
}
break;
case IPCEngineGuest::NotifyBreakpointAdjusted:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
BreakpointId id;
BreakpointParameters d;
s >> id >> d;
breakHandler()->notifyBreakpointAdjusted(id, d);
}
break;
case IPCEngineGuest::FrameSourceFetched:
{
QDataStream s(payload);
SET_NATIVE_BYTE_ORDER(s);
qint64 token;
QString path;
QString source;
s >> token >> path >> source;
SourceAgent *agent = new SourceAgent(this);
agent->setSourceProducerName(startParameters().connParams.host);
agent->setContent(path, source);
m_sourceAgents.insert(path, agent);
agent->updateLocationMarker();
}
break;
}
}
void PdbEngine::postDirectCommand(const QByteArray &command)
{
QTC_ASSERT(m_pdbProc.state() == QProcess::Running, notifyEngineIll());
showMessage(_(command), LogInput);
m_pdbProc.write(command + '\n');
}