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(); } }