void LldbEngine::updateBreakpointData(const GdbMi &bkpt, bool added)
{
BreakHandler *handler = breakHandler();
BreakpointResponseId rid = BreakpointResponseId(bkpt["lldbid"].data());
BreakpointModelId id = BreakpointModelId(bkpt["modelid"].data());
Breakpoint bp = handler->breakpointById(id);
if (!bp.isValid())
bp = handler->findBreakpointByResponseId(rid);
BreakpointResponse response = bp.response();
if (added)
response.id = rid;
QTC_CHECK(response.id == rid);
response.address = 0;
response.enabled = bkpt["enabled"].toInt();
response.ignoreCount = bkpt["ignorecount"].toInt();
response.condition = QByteArray::fromHex(bkpt["condition"].data());
response.hitCount = bkpt["hitcount"].toInt();
response.fileName = bkpt["file"].toUtf8();
response.lineNumber = bkpt["line"].toInt();
GdbMi locations = bkpt["locations"];
const int numChild = int(locations.children().size());
if (numChild > 1) {
foreach (const GdbMi &location, locations.children()) {
const int locid = location["locid"].toInt();
BreakpointResponse sub;
sub.id = BreakpointResponseId(rid.majorPart(), locid);
sub.type = response.type;
sub.address = location["addr"].toAddress();
sub.functionName = location["func"].toUtf8();
sub.fileName = location["file"].toUtf8();
sub.lineNumber = location["line"].toInt();
bp.insertSubBreakpoint(sub);
}
} else if (numChild == 1) {
// ---------------------------------------------------------------------------
// resetEnvelopes
// ---------------------------------------------------------------------------
// Reset the instantaneous envelope parameters
// (frequency, amplitude, bandwidth, and phase).
// The sample rate is needed to convert the
// Breakpoint frequency (Hz) to radians per sample.
//
void
Oscillator::resetEnvelopes( const Breakpoint & bp, double srate )
{
// Remember that the oscillator only knows about
// radian frequency! Convert!
i_frequency = bp.frequency() * TwoPi / srate;
i_amplitude = bp.amplitude();
i_bandwidth = bp.bandwidth();
determ_phase = bp.phase();
// clamp bandwidth:
if ( i_bandwidth > 1. )
{
debugger << "clamping bandwidth at 1." << endl;
i_bandwidth = 1.;
}
else if ( i_bandwidth < 0. )
{
debugger << "clamping bandwidth at 0." << endl;
i_bandwidth = 0.;
}
// don't alias:
if ( i_frequency > Pi )
{
debugger << "fading out aliasing Partial" << endl;
i_amplitude = 0.;
}
}
bool
DebugState::clearBreakpointsIn(JSContext* cx, WasmInstanceObject* instance, js::Debugger* dbg, JSObject* handler)
{
MOZ_ASSERT(instance);
if (!breakpointSites_.initialized())
return true;
// Make copy of all sites list, so breakpointSites_ can be modified by
// destroyBreakpointSite calls.
Vector<WasmBreakpointSite*> sites(cx);
if (!sites.resize(breakpointSites_.count()))
return false;
size_t i = 0;
for (WasmBreakpointSiteMap::Range r = breakpointSites_.all(); !r.empty(); r.popFront())
sites[i++] = r.front().value();
for (WasmBreakpointSite* site : sites) {
Breakpoint* nextbp;
for (Breakpoint* bp = site->firstBreakpoint(); bp; bp = nextbp) {
nextbp = bp->nextInSite();
if (bp->asWasm()->wasmInstance == instance &&
(!dbg || bp->debugger == dbg) &&
(!handler || bp->getHandler() == handler))
{
bp->destroy(cx->runtime()->defaultFreeOp());
}
}
}
return true;
}
void
JSCompartment::sweepBreakpoints(JSContext *cx)
{
if (JS_CLIST_IS_EMPTY(&cx->runtime->debuggerList))
return;
for (CellIterUnderGC i(this, FINALIZE_SCRIPT); !i.done(); i.next()) {
JSScript *script = i.get<JSScript>();
if (!script->hasAnyBreakpointsOrStepMode())
continue;
bool scriptGone = IsAboutToBeFinalized(cx, script);
for (unsigned i = 0; i < script->length; i++) {
BreakpointSite *site = script->getBreakpointSite(script->code + i);
if (!site)
continue;
// nextbp is necessary here to avoid possibly reading *bp after
// destroying it.
Breakpoint *nextbp;
for (Breakpoint *bp = site->firstBreakpoint(); bp; bp = nextbp) {
nextbp = bp->nextInSite();
if (scriptGone || IsAboutToBeFinalized(cx, bp->debugger->toJSObject()))
bp->destroy(cx);
}
}
}
}
// ---------------------------------------------------------------------------
// resetEnvelopes
// ---------------------------------------------------------------------------
// Reset the instantaneous envelope parameters
// (frequency, amplitude, bandwidth, and phase).
// The Breakpoint frequency (Hz) is in radians per sample.
void
RealtimeOscillator::restoreEnvelopes( const Breakpoint & bp) noexcept
{
// Remember that the oscillator only knows about
// radian frequency! Convert!
m_instfrequency = bp.frequency();
m_instamplitude = bp.amplitude();
m_instbandwidth = bp.bandwidth();
m_determphase = bp.phase();
// clamp bandwidth:
if ( m_instbandwidth > 1. )
{
m_instbandwidth = 1.;
}
else if ( m_instbandwidth < 0. )
{
m_instbandwidth = 0.;
}
// don't alias:
if ( m_instfrequency > Pi )
{
m_instamplitude = 0.;
}
// Reset the fitler state too.
m_filter.clear();
}
void
JSCompartment::sweepBreakpoints(FreeOp *fop)
{
gcstats::AutoPhase ap(rt->gcStats, gcstats::PHASE_SWEEP_TABLES_BREAKPOINT);
if (rt->debuggerList.isEmpty())
return;
for (CellIterUnderGC i(zone(), FINALIZE_SCRIPT); !i.done(); i.next()) {
JSScript *script = i.get<JSScript>();
if (script->compartment() != this || !script->hasAnyBreakpointsOrStepMode())
continue;
bool scriptGone = IsScriptAboutToBeFinalized(&script);
JS_ASSERT(script == i.get<JSScript>());
for (unsigned i = 0; i < script->length; i++) {
BreakpointSite *site = script->getBreakpointSite(script->code + i);
if (!site)
continue;
// nextbp is necessary here to avoid possibly reading *bp after
// destroying it.
Breakpoint *nextbp;
for (Breakpoint *bp = site->firstBreakpoint(); bp; bp = nextbp) {
nextbp = bp->nextInSite();
if (scriptGone || IsObjectAboutToBeFinalized(&bp->debugger->toJSObjectRef()))
bp->destroy(fop);
}
}
}
}
void DebuggerIPCServer::handleSetBreakpoint(
PFPSimDebugger::SetBreakpointMsg msg) {
int size = msg.condition_list_size();
Breakpoint br;
if (msg.temporary() == "1") {
br.temp = true;
}
if (msg.disabled() == "1") {
br.disabled = true;
} for (int i = 0; i < size; i++) {
PFPSimDebugger::BreakpointCondition condition = msg.condition_list(i);
std::string value = msg.value_list(i);
if (condition
== PFPSimDebugger::BreakpointCondition::BREAK_ON_MODULE_READ) {
br.addCondition(
Breakpoint::BreakpointCondition::BREAK_ON_MODULE_READ, value);
} else if (condition
== PFPSimDebugger::BreakpointCondition::BREAK_ON_MODULE_WRITE) {
br.addCondition(
Breakpoint::BreakpointCondition::BREAK_ON_MODULE_WRITE, value);
} else if (condition
== PFPSimDebugger::BreakpointCondition::BREAK_ON_PACKET_ID) {
br.addCondition(
Breakpoint::BreakpointCondition::BREAK_ON_PACKET_ID, value);
} else if (condition
== PFPSimDebugger::BreakpointCondition::BREAK_AT_TIME) {
br.addCondition(Breakpoint::BreakpointCondition::BREAK_AT_TIME, value);
br.temp = true;
}
}
data_manager->addBreakpoint(br);
sendGenericReply();
}
void LldbEngine::insertBreakpoint(Breakpoint bp)
{
DebuggerCommand cmd("insertBreakpoint");
bp.addToCommand(&cmd);
bp.notifyBreakpointInsertProceeding();
runCommand(cmd);
}
void BreakpointModel::markChanged(
KTextEditor::Document *document,
KTextEditor::Mark mark,
KTextEditor::MarkInterface::MarkChangeAction action)
{
int type = mark.type;
/* Is this a breakpoint mark, to begin with? */
if (!(type & AllBreakpointMarks)) return;
if (action == KTextEditor::MarkInterface::MarkAdded) {
Breakpoint *b = breakpoint(document->url(), mark.line);
if (b) {
//there was already a breakpoint, so delete instead of adding
b->setDeleted();
return;
}
Breakpoint *breakpoint = addCodeBreakpoint(document->url(), mark.line);
KTextEditor::MovingInterface *moving = qobject_cast<KTextEditor::MovingInterface*>(document);
if (moving) {
KTextEditor::MovingCursor* cursor = moving->newMovingCursor(KTextEditor::Cursor(mark.line, 0));
// can't use new signal/slot syntax here, MovingInterface is not a QObject
connect(document, SIGNAL(aboutToDeleteMovingInterfaceContent(KTextEditor::Document*)),
this, SLOT(aboutToDeleteMovingInterfaceContent(KTextEditor::Document*)), Qt::UniqueConnection);
breakpoint->setMovingCursor(cursor);
}
} else {
bool Debugger::hasBreakpoint(SourceID sourceID, const TextPosition& position, Breakpoint *hitBreakpoint)
{
if (!m_breakpointsActivated)
return false;
SourceIDToBreakpointsMap::const_iterator it = m_sourceIDToBreakpoints.find(sourceID);
if (it == m_sourceIDToBreakpoints.end())
return false;
unsigned line = position.m_line.zeroBasedInt();
unsigned column = position.m_column.zeroBasedInt();
LineToBreakpointsMap::const_iterator breaksIt = it->value.find(line);
if (breaksIt == it->value.end())
return false;
bool hit = false;
const BreakpointsList& breakpoints = *breaksIt->value;
Breakpoint* breakpoint;
for (breakpoint = breakpoints.head(); breakpoint; breakpoint = breakpoint->next()) {
unsigned breakLine = breakpoint->line;
unsigned breakColumn = breakpoint->column;
// Since frontend truncates the indent, the first statement in a line must match the breakpoint (line,0).
ASSERT(this == m_currentCallFrame->codeBlock()->globalObject()->debugger());
if ((line != m_lastExecutedLine && line == breakLine && !breakColumn)
|| (line == breakLine && column == breakColumn)) {
hit = true;
break;
}
}
if (!hit)
return false;
if (hitBreakpoint)
*hitBreakpoint = *breakpoint;
if (breakpoint->condition.isEmpty())
return true;
// We cannot stop in the debugger while executing condition code,
// so make it looks like the debugger is already paused.
TemporaryPausedState pausedState(*this);
JSValue exception;
DebuggerCallFrame* debuggerCallFrame = currentDebuggerCallFrame();
JSValue result = debuggerCallFrame->evaluate(breakpoint->condition, exception);
// We can lose the debugger while executing JavaScript.
if (!m_currentCallFrame)
return false;
if (exception) {
// An erroneous condition counts as "false".
handleExceptionInBreakpointCondition(m_currentCallFrame, exception);
return false;
}
return result.toBoolean(m_currentCallFrame);
}
// ---------------------------------------------------------------------------
// phaseTravel
//
// Compute the sinusoidal phase travel between two Breakpoints.
// Return the total unwrapped phase travel.
//
double phaseTravel( const Breakpoint & bp0, const Breakpoint & bp1,
double dt )
{
double f0 = bp0.frequency();
double f1 = bp1.frequency();
double favg = .5 * ( f0 + f1 );
return 2 * Pi * favg * dt;
}
void LldbEngine::removeBreakpoint(Breakpoint bp)
{
const BreakpointResponse &response = bp.response();
DebuggerCommand cmd("removeBreakpoint");
cmd.arg("modelid", bp.id().toByteArray());
cmd.arg("lldbid", response.id.toByteArray());
bp.notifyBreakpointRemoveProceeding();
runCommand(cmd);
}
// http://www.koders.com/cpp/fidBA6CD8A0FE5F41F1464D74733D9A711DA257D20B.aspx?s=PyEval_SetTrace
// http://code.google.com/p/idapython/source/browse/trunk/python.cpp
// http://www.koders.com/cpp/fid191F7B13CF73133935A7A2E18B7BF43ACC6D1784.aspx?s=PyEval_SetTrace
// http://stuff.mit.edu/afs/sipb/project/python/src/python2.2-2.2.2/Modules/_hotshot.c
int PythonDebugger::tracer_callback(PyObject *obj, PyFrameObject *frame, int what, PyObject *arg)
{
PythonDebuggerPy* self = static_cast<PythonDebuggerPy*>(obj);
PythonDebugger* dbg = self->dbg;
if (dbg->d->trystop)
PyErr_SetInterrupt();
QCoreApplication::processEvents();
//int no;
//no = frame->f_tstate->recursion_depth;
//char* name = PyString_AsString(frame->f_code->co_name);
QString file = QString::fromUtf8(PyString_AsString(frame->f_code->co_filename));
switch (what) {
case PyTrace_CALL:
self->depth++;
return 0;
case PyTrace_RETURN:
if (self->depth > 0)
self->depth--;
return 0;
case PyTrace_LINE:
{
//PyObject *str;
//str = PyObject_Str(frame->f_code->co_filename);
//no = frame->f_lineno;
int line = PyCode_Addr2Line(frame->f_code, frame->f_lasti);
//if (str) {
// Base::Console().Message("PROFILING: %s:%d\n", PyString_AsString(str), frame->f_lineno);
// Py_DECREF(str);
//}
// For testing only
if (!dbg->d->trystop) {
Breakpoint bp = dbg->getBreakpoint(file);
if (bp.checkLine(line)) {
dbg->showDebugMarker(file, line);
QEventLoop loop;
QObject::connect(dbg, SIGNAL(signalNextStep()), &loop, SLOT(quit()));
loop.exec();
dbg->hideDebugMarker(file);
}
}
return 0;
}
case PyTrace_EXCEPTION:
return 0;
case PyTrace_C_CALL:
return 0;
case PyTrace_C_EXCEPTION:
return 0;
case PyTrace_C_RETURN:
return 0;
default:
/* ignore PyTrace_EXCEPTION */
break;
}
return 0;
}
void dissemble(PFBlock fb)
{
Opcodes opcode;
int rmode,rdata, k = 0;
string name;
Instruction *pi = fb->pstart;
while (pi != end_of_code) {
opcode = (Opcodes)pi->opcode;
// *add 1.2.4 HALT+data is not always a breakpoint!
// (it is used as a NOP + <any useful tag data>)
if (opcode == HALT) {
if (pi->data < MAX_BREAKPOINTS) {
Breakpoint *pb = Breakpoint::from_id(pi->data);
Instruction ai = pb->saved_instruction();
std::cout << "*";
opcode = (Opcodes)ai.opcode;
rmode = ai.rmode; rdata = ai.data;
} else { opcode = NOP; rdata = pi->data; }
} else {
rmode = pi->rmode; rdata = pi->data;
}
name = get_opcode_name(opcode);
std::cout << k++ << ' ' << name << '\t';
if (opcode == CCALL || opcode == CALL || opcode == CALLD || opcode == CALLN) {
FBlock* pfb;
void *data = data_ptr(rdata);
if (opcode == CALLN)
pfb = Builtin::imported_fblock_from_function((void*)((NFBlock *)data)->pfn);
else pfb = PFBlock(data_ptr(rdata));
if (pfb) Function::from_fun_block(pfb)->dump(std::cout);
} else
if (opcode == JSWITCH) {
int *swb = (int *)data_ptr(rdata);
int sz = *swb++;
int def = *swb++;
std::cout << '(' << sz << ',' << def << ") ";
for (int i = 0; i < sz; i++) std::cout << *swb++ << ' ' << *swb++ << ' ';
}
else
if (opcode == TOSD || opcode == TPODS) {
PClass pc = *(PClass *)data_ptr(rdata);
std::cout << pc->name();
}
else {
if (rmode)
switch(rmode) {
case DIRECT: std::cout << "D "; break;
case SREL: std::cout << "R "; break;
case OREL: std::cout << "S "; break;
}
if (rdata != 0) std::cout << rdata;
}
std::cout << std::endl;
if (opcode == RET || opcode == RETI || opcode == RETD) break;
pi++;
}
}
/// Refresh the breakpoint marks.
void OnChangedBreakpoints(wxDebugEvent &/*event*/) {
MarkerDeleteAll(MARKNUM_BREAKPOINT);
BreakpointList &bps = Mediator::Get()->GetBreakpoints();
Breakpoint bp;
for (bp = bps.First(GetKey()); bp.IsOk(); bp = bps.Next(bp)) {
MarkerAdd(bp.GetLine(), MARKNUM_BREAKPOINT);
}
}
void LldbEngine::changeBreakpoint(Breakpoint bp)
{
const BreakpointResponse &response = bp.response();
DebuggerCommand cmd("changeBreakpoint");
cmd.arg("lldbid", response.id.toByteArray());
bp.addToCommand(&cmd);
bp.notifyBreakpointChangeProceeding();
runCommand(cmd);
}
void PdbEngine::removeBreakpoint(Breakpoint bp)
{
QTC_CHECK(bp.state() == BreakpointRemoveRequested);
bp.notifyBreakpointRemoveProceeding();
BreakpointResponse br = bp.response();
showMessage(_("DELETING BP %1 IN %2").arg(br.id.toString()).arg(bp.fileName()));
postDirectCommand("clear " + br.id.toByteArray());
// Pretend it succeeds without waiting for response.
bp.notifyBreakpointRemoveOk();
}
void
ThreadPlanRunToAddress::GetDescription (Stream *s, lldb::DescriptionLevel level)
{
size_t num_addresses = m_addresses.size();
if (level == lldb::eDescriptionLevelBrief)
{
if (num_addresses == 0)
{
s->Printf ("run to address with no addresses given.");
return;
}
else if (num_addresses == 1)
s->Printf ("run to address: ");
else
s->Printf ("run to addresses: ");
for (size_t i = 0; i < num_addresses; i++)
{
s->Address (m_addresses[i], sizeof (addr_t));
s->Printf(" ");
}
}
else
{
if (num_addresses == 0)
{
s->Printf ("run to address with no addresses given.");
return;
}
else if (num_addresses == 1)
s->Printf ("Run to address: ");
else
{
s->Printf ("Run to addresses: ");
}
for (size_t i = 0; i < num_addresses; i++)
{
if (num_addresses > 1)
{
s->Printf("\n");
s->Indent();
}
s->Address(m_addresses[i], sizeof (addr_t));
s->Printf (" using breakpoint: %d - ", m_break_ids[i]);
Breakpoint *breakpoint = m_thread.GetProcess().GetTarget().GetBreakpointByID (m_break_ids[i]).get();
if (breakpoint)
breakpoint->Dump (s);
else
s->Printf ("but the breakpoint has been deleted.");
}
}
}
// ---------------------------------------------------------------------------
// accum_samples
// ---------------------------------------------------------------------------
// helper
//
static void accum_samples( CSOUND * csound,
Oscillator & oscil, Breakpoint & bp,
double * bufbegin )
{
if( bp.amplitude() > 0 || oscil.amplitude() > 0 )
{
double radfreq = radianFreq( csound, bp.frequency() );
double amp = bp.amplitude();
double bw = bp.bandwidth();
// initialize the oscillator if it is changing from zero
// to non-zero amplitude in this control block:
if ( oscil.amplitude() == 0. )
{
// don't initialize with bogus values, Oscillator
// only guards against out-of-range target values
// in generateSamples(), parameter mutators are
// dangerous:
if ( radfreq > PI ) // don't alias
amp = 0.;
if ( bw > 1. ) // clamp bandwidth
bw = 1.;
else if ( bw < 0. )
bw = 0.;
#ifdef DEBUG_LORISGENS
/*
std::cerr << "initializing oscillator " << std::endl;
std::cerr << "parameters: " << bp.frequency() << " ";
std::cerr << amp << " " << bw << std::endl;
*/
#endif
// initialize frequency, amplitude, and bandwidth to
// their target values:
/*
oscil.setRadianFreq( radfreq );
oscil.setAmplitude( amp );
oscil.setBandwidth( bw );
*/
oscil.resetEnvelopes( bp, (double) csound->esr );
// roll back the phase:
oscil.resetPhase( bp.phase() - ( radfreq * (double) csound->ksmps ) );
}
// accumulate samples into buffer:
// oscil.generateSamples( bufbegin, bufbegin + nsamps, radfreq, amp, bw );
oscil.oscillate( bufbegin, bufbegin + csound->ksmps,
bp, (double) csound->esr );
}
}
bool
ThreadHandler::HandleBreakpointHit(BreakpointHitEvent* event)
{
CpuState* cpuState = event->GetCpuState();
target_addr_t instructionPointer = cpuState->InstructionPointer();
TRACE_EVENTS("ThreadHandler::HandleBreakpointHit(): ip: %" B_PRIx64 "\n",
instructionPointer);
// check whether this is a temporary breakpoint we're waiting for
if (fBreakpointAddress != 0 && instructionPointer == fBreakpointAddress
&& fStepMode != STEP_NONE) {
if (fStepMode != STEP_UNTIL && _HandleBreakpointHitStep(cpuState))
return true;
} else {
// Might be a user breakpoint, but could as well be a temporary
// breakpoint of another thread.
AutoLocker<Team> locker(fThread->GetTeam());
Breakpoint* breakpoint = fThread->GetTeam()->BreakpointAtAddress(
cpuState->InstructionPointer());
bool continueThread = false;
if (breakpoint == NULL) {
// spurious breakpoint -- might be a temporary breakpoint, that has
// already been uninstalled
continueThread = true;
} else if (!breakpoint->HasEnabledUserBreakpoint()) {
// breakpoint of another thread or one that has been disabled in
// the meantime
continueThread = true;
}
if (continueThread) {
if (fSingleStepping) {
// We might have hit a just-installed software breakpoint and
// thus haven't stepped at all. Just try again.
if (fPreviousInstructionPointer == instructionPointer) {
fDebuggerInterface->SingleStepThread(ThreadID());
return true;
}
// That shouldn't happen. Try something reasonable anyway.
if (fStepMode != STEP_NONE) {
if (_HandleSingleStepStep(cpuState))
return true;
}
}
return false;
}
}
return _HandleThreadStopped(cpuState, THREAD_STOPPED_BREAKPOINT);
}
lldb::BreakpointLocationSP
Breakpoint::BreakpointEventData::GetBreakpointLocationAtIndexFromEvent (const lldb::EventSP &event_sp, uint32_t bp_loc_idx)
{
lldb::BreakpointLocationSP bp_loc_sp;
BreakpointEventData *data = GetEventDataFromEvent (event_sp);
if (data)
{
Breakpoint *bp = data->GetBreakpoint().get();
if (bp)
bp_loc_sp = bp->GetLocationAtIndex(bp_loc_idx);
}
return bp_loc_sp;
}
BreakpointLocation::BreakpointLocation
(
break_id_t loc_id,
Breakpoint &owner,
const Address &addr,
lldb::tid_t tid,
bool hardware,
bool check_for_resolver
) :
StoppointLocation (loc_id, addr.GetOpcodeLoadAddress(&owner.GetTarget()), hardware),
m_being_created(true),
m_should_resolve_indirect_functions (false),
m_is_reexported (false),
m_is_indirect (false),
m_address (addr),
m_owner (owner),
m_options_ap (),
m_bp_site_sp (),
m_condition_mutex ()
{
if (check_for_resolver)
{
Symbol *symbol = m_address.CalculateSymbolContextSymbol();
if (symbol && symbol->IsIndirect())
{
SetShouldResolveIndirectFunctions (true);
}
}
SetThreadID (tid);
m_being_created = false;
}
void ThreadPlanRunToAddress::SetInitialBreakpoints() {
size_t num_addresses = m_addresses.size();
m_break_ids.resize(num_addresses);
for (size_t i = 0; i < num_addresses; i++) {
Breakpoint *breakpoint;
breakpoint = m_thread.CalculateTarget()
->CreateBreakpoint(m_addresses[i], true, false)
.get();
if (breakpoint != nullptr) {
m_break_ids[i] = breakpoint->GetID();
breakpoint->SetThreadID(m_thread.GetID());
breakpoint->SetBreakpointKind("run-to-address");
}
}
}
void
ThreadPlanRunToAddress::SetInitialBreakpoints ()
{
size_t num_addresses = m_addresses.size();
m_break_ids.resize(num_addresses);
for (size_t i = 0; i < num_addresses; i++)
{
Breakpoint *breakpoint;
breakpoint = m_thread.GetProcess().GetTarget().CreateBreakpoint (m_addresses[i], true).get();
if (breakpoint != NULL)
{
m_break_ids[i] = breakpoint->GetID();
breakpoint->SetThreadID(m_thread.GetID());
}
}
}
void
TeamDebugger::_HandleClearUserBreakpoint(target_addr_t address)
{
TRACE_CONTROL("TeamDebugger::_HandleClearUserBreakpoint(%#llx)\n", address);
AutoLocker< ::Team> locker(fTeam);
Breakpoint* breakpoint = fTeam->BreakpointAtAddress(address);
if (breakpoint == NULL || breakpoint->FirstUserBreakpoint() == NULL)
return;
UserBreakpoint* userBreakpoint
= breakpoint->FirstUserBreakpoint()->GetUserBreakpoint();
BReference<UserBreakpoint> userBreakpointReference(userBreakpoint);
locker.Unlock();
_HandleClearUserBreakpoint(userBreakpoint);
}
void
JSCompartment::clearBreakpointsIn(JSContext *cx, js::Debugger *dbg, JSScript *script,
JSObject *handler)
{
JS_ASSERT_IF(script, script->compartment() == this);
for (BreakpointSiteMap::Enum e(breakpointSites); !e.empty(); e.popFront()) {
BreakpointSite *site = e.front().value;
if (!script || site->script == script) {
Breakpoint *nextbp;
for (Breakpoint *bp = site->firstBreakpoint(); bp; bp = nextbp) {
nextbp = bp->nextInSite();
if ((!dbg || bp->debugger == dbg) && (!handler || bp->getHandler() == handler))
bp->destroy(cx, &e);
}
}
}
}
bool LldbEngine::acceptsBreakpoint(Breakpoint bp) const
{
if (runParameters().startMode == AttachCore)
return false;
// We handle QML breakpoint unless specifically disabled.
if (isNativeMixedEnabled() && !(runParameters().languages & QmlLanguage))
return true;
return bp.parameters().isCppBreakpoint();
}
//------------------------------------------------------------------
// Setup the JIT Breakpoint
//------------------------------------------------------------------
void
JITLoaderGDB::SetJITBreakpoint(lldb_private::ModuleList &module_list)
{
if (!GetGlobalPluginProperties()->GetEnableJITBreakpoint())
return;
if ( DidSetJITBreakpoint() )
return;
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_JIT_LOADER));
if (log)
log->Printf("JITLoaderGDB::%s looking for JIT register hook",
__FUNCTION__);
addr_t jit_addr = GetSymbolAddress(module_list,
ConstString("__jit_debug_register_code"),
eSymbolTypeAny);
if (jit_addr == LLDB_INVALID_ADDRESS)
return;
m_jit_descriptor_addr = GetSymbolAddress(module_list,
ConstString("__jit_debug_descriptor"),
eSymbolTypeData);
if (m_jit_descriptor_addr == LLDB_INVALID_ADDRESS)
{
if (log)
log->Printf(
"JITLoaderGDB::%s failed to find JIT descriptor address",
__FUNCTION__);
return;
}
if (log)
log->Printf("JITLoaderGDB::%s setting JIT breakpoint",
__FUNCTION__);
Breakpoint *bp =
m_process->GetTarget().CreateBreakpoint(jit_addr, true, false).get();
bp->SetCallback(JITDebugBreakpointHit, this, true);
bp->SetBreakpointKind("jit-debug-register");
m_jit_break_id = bp->GetID();
ReadJITDescriptor(true);
}
/**
* Takes the active breakpoints to create a map that is used to count
* breakpoint hits and how much time is spent in blocks.
**/
std::map<Offset, TimedBlock*> initBlockMap()
{
std::map<Offset, TimedBlock*> timedBlocks;
IdaFile file = IdaFile();
Debugger debugger = file.getDebugger();
// Initialize the time of each basic block to 0
for (unsigned int i=0;i<debugger.getNumberOfBreakpoints();i++)
{
Breakpoint bp = debugger.getBreakpoint(i);
Offset breakpointAddress = bp.getAddress();
timedBlocks[breakpointAddress] = new TimedBlock(breakpointAddress);
}
return timedBlocks;
}
void InterruptibleModule::calledGetModuleState() {
Breakpoint *bp = NULL;
// Check if it's necessary to call the breakpoint.
{
Lock l(m_breakpointMutex);
bp = m_breakpoint;
}
// Reach breakpoint.
if (bp != NULL) {
bp->reached();
// Yielding other threads to deliver containers.
Thread::usleep(100);
}
else {
// Yielding other threads and adjust to a fixed frequency if no breakpoint is set.
wait();
}
}
