// Operators
const BreakpointOptions &operator=(const BreakpointOptions &rhs);
-
+
/// Copy over only the options set in the incoming BreakpointOptions.
void CopyOverSetOptions(const BreakpointOptions &rhs);
bool IsEnabled() const { return m_enabled; }
/// If \a enable is \b true, enable the breakpoint, if \b false disable it.
- void SetEnabled(bool enabled) {
+ void SetEnabled(bool enabled) {
m_enabled = enabled;
m_set_flags.Set(eEnabled);
}
bool IsAutoContinue() const { return m_auto_continue; }
/// Set the auto-continue state.
- void SetAutoContinue(bool auto_continue) {
+ void SetAutoContinue(bool auto_continue) {
m_auto_continue = auto_continue;
m_set_flags.Set(eAutoContinue);
}
bool IsOneShot() const { return m_one_shot; }
/// If \a enable is \b true, enable the breakpoint, if \b false disable it.
- void SetOneShot(bool one_shot) {
- m_one_shot = one_shot;
- m_set_flags.Set(eOneShot);
+ void SetOneShot(bool one_shot) {
+ m_one_shot = one_shot;
+ m_set_flags.Set(eOneShot);
}
/// Set the breakpoint to ignore the next \a count breakpoint hits.
- /// \param[in] count
+ /// \param[in] n
/// The number of breakpoint hits to ignore.
-
- void SetIgnoreCount(uint32_t n) {
- m_ignore_count = n;
+ void SetIgnoreCount(uint32_t n) {
+ m_ignore_count = n;
m_set_flags.Set(eIgnoreCount);
}
/// A UP holding the new'ed CommandData object.
/// The breakpoint will take ownership of pointer held by this object.
void SetCommandDataCallback(std::unique_ptr<CommandData> &cmd_data);
-
+
void Clear();
-
+
bool AnySet() const {
return m_set_flags.AnySet(eAllOptions);
}
-
+
protected:
// Classes that inherit from BreakpointOptions can see and modify these
bool IsOptionSet(OptionKind kind)
private:
/// For BreakpointOptions only
-
+
/// This is the callback function pointer
BreakpointHitCallback m_callback;
/// This is the client data for the callback
///
/// Initialize the address with the supplied \a section and \a offset.
///
- /// \param[in] section
+ /// \param[in] section_sp
/// A section pointer to a valid lldb::Section, or NULL if the
/// address doesn't have a section or will get resolved later.
///
/// Set accessor for the section.
///
- /// \param[in] section
+ /// \param[in] section_sp
/// A new lldb::Section pointer to use as the section base. Can
/// be NULL for absolute addresses that are not relative to
/// any section.
///
/// Initializes class variables.
///
- /// \param[in] exe_scope,
+ /// \param[in] exe_scope
/// If non-NULL, an execution context scope that can help to
/// correctly create an expression with a valid process for
/// optional tuning Objective-C runtime support. Can be NULL.
virtual bool Install(DiagnosticManager &diagnostic_manager,
ExecutionContext &exe_ctx) = 0;
- /// Check whether the given PC is inside the function
+ /// Check whether the given address is inside the function
///
/// Especially useful if the function dereferences nullptr to indicate a
/// failed assert.
///
- /// \param[in] pc
- /// The program counter to check.
+ /// \param[in] address
+ /// The address to check.
///
/// \return
- /// True if the program counter falls within the function's bounds;
+ /// True if the address falls within the function's bounds;
/// false if not (or the function is not JIT compiled)
bool ContainsAddress(lldb::addr_t address) {
// nothing is both >= LLDB_INVALID_ADDRESS and < LLDB_INVALID_ADDRESS, so
/// Get the command that appropriate for a "repeat" of the current command.
///
- /// \param[in] current_command_line
- /// The complete current command line.
+ /// \param[in] current_command_args
+ /// The command arguments.
///
/// \return
/// nullptr if there is no special repeat command - it will use the
/// the core file.
///
/// \return
- // true if the user should be warned about detaching from this process.
+ /// Returns \b true if the user should be warned about detaching from
+ /// this process.
virtual bool WarnBeforeDetach() const { return true; }
/// Actually do the reading of memory from a process.
user_id_t break_loc_id) {
assert(baton && "null baton");
if (!baton)
- return false; //< false => resume execution.
+ return false; ///< false => resume execution.
MainThreadCheckerRuntime *const instance =
static_cast<MainThreadCheckerRuntime *>(baton);
StructuredData::ObjectSP info) {
ThreadCollectionSP threads;
threads = std::make_shared<ThreadCollection>();
-
+
ProcessSP process_sp = GetProcessSP();
-
+
if (info->GetObjectForDotSeparatedPath("instrumentation_class")
->GetStringValue() != "MainThreadChecker")
return threads;
-
+
std::vector<lldb::addr_t> PCs;
auto trace = info->GetObjectForDotSeparatedPath("trace")->GetAsArray();
trace->ForEach([&PCs](StructuredData::Object *PC) -> bool {
PCs.push_back(PC->GetAsInteger()->GetValue());
return true;
});
-
+
if (PCs.empty())
return threads;
-
+
StructuredData::ObjectSP thread_id_obj =
info->GetObjectForDotSeparatedPath("tid");
tid_t tid = thread_id_obj ? thread_id_obj->GetIntegerValue() : 0;
HistoryThread *history_thread = new HistoryThread(*process_sp, tid, PCs);
ThreadSP new_thread_sp(history_thread);
-
+
// Save this in the Process' ExtendedThreadList so a strong pointer retains
// the object
process_sp->GetExtendedThreadList().AddThread(new_thread_sp);