[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

clayborg added a comment. In D58678#1530031 , @lanza wrote: > @clayborg Seems like this still steps into the `call` if the call is the last > instruction in the range. `ThreadPlanStepRange::SetNextBranchBreakpoint` > checks `if (last_index - pc_index >

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

lanza added a comment. @clayborg Seems like this still steps into the `call` if the call is the last instruction in the range. `ThreadPlanStepRange::SetNextBranchBreakpoint` checks `if (last_index - pc_index > 1)` before setting the breakpoint. So if `last_index == pc_index` and `pc` points to

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

jingham added a comment. The one outstanding bit of work here is that this change requires that the MSInst "IsCall" function has to mean "will return to the next instruction after call" or we might lose control of the program. It seems obvious that that SHOULD be what it means, but we need to

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

This revision was automatically updated to reflect the committed changes. Closed by commit rLLDB360375: Improve step over performance by not stopping at branches that are function… (authored by gclayton, committed by ). Repository: rLLDB LLDB CHANGES SINCE LAST ACTION

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

JDevlieghere accepted this revision. JDevlieghere added a comment. This revision is now accepted and ready to land. Alright, thanks for the explanation. Assuming Jim has no objections this LGTM. Repository: rLLDB LLDB CHANGES SINCE LAST ACTION https://reviews.llvm.org/D58678/new/

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

jingham added a comment. I'm fine with leaving the reporting as is. This really only happens in fairly restricted situations (only hardware breakpoints) and neither way of reporting the failure seems much better to me, so we needn't over-polish it. Repository: rLLDB LLDB CHANGES SINCE

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

clayborg added a comment. In D58678#1410970 , @jingham wrote: > I have two questions about this patch. > > 1. I want some llvm expert to weigh in on whether > > m_instructions[i]->IsCall() > > always means it returns to the next instruction after the

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

jingham added a comment. I have two questions about this patch. 1. I want some llvm expert to weigh in on whether m_instructions[i]->IsCall() always means it returns to the next instruction after the call. That seems obvious, but since this patch depends on that being true, I'd like to know

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

clayborg marked 2 inline comments as done. clayborg added inline comments. Comment at: include/lldb/Core/Disassembler.h:309 + /// It true, then fine the first branch instruction that isn't + /// a function call (a branch that calls and returns to the next + ///

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

jingham added a comment. In D58678#1410861 , @zturner wrote: > > Since we are stepping over we can safely ignore these calls since they will > > return to the next instruction > > What if the call throws an exception? This patch won't change lldb's

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

zturner added a comment. > Since we are stepping over we can safely ignore these calls since they will > return to the next instruction What if the call throws an exception? Repository: rLLDB LLDB CHANGES SINCE LAST ACTION https://reviews.llvm.org/D58678/new/

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

JDevlieghere added inline comments. Comment at: include/lldb/Core/Disassembler.h:309 + /// It true, then fine the first branch instruction that isn't + /// a function call (a branch that calls and returns to the next + /// instruction). If false, find the

[Lldb-commits] [PATCH] D58678: Improve step over performance by not stopping at branches that are function calls and stepping into and them out of each one

clayborg created this revision. clayborg added a reviewer: jingham. Herald added a reviewer: serge-sans-paille. Herald added a project: LLDB. Currently when we single step over a source line, we run and stop at every branch in the source line range. We can reduce the number of times we stop when