[Lldb-commits] [lldb] Add the ability to break on call-site locations, improve inline stepping (PR #112939)
via lldb-commits
lldb-commits at lists.llvm.org
Fri Oct 18 10:28:40 PDT 2024
github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code. :warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff 7da0a698526ff657c2348a6e4bb835fc764177da 9c6705b21df14dc911665e1082c9b31ce00d7e7c --extensions h,cpp -- lldb/include/lldb/Breakpoint/BreakpointLocation.h lldb/include/lldb/Breakpoint/BreakpointSite.h lldb/include/lldb/Target/StopInfo.h lldb/include/lldb/Target/ThreadPlanStepInRange.h lldb/source/Breakpoint/BreakpointLocation.cpp lldb/source/Breakpoint/BreakpointResolver.cpp lldb/source/Breakpoint/BreakpointSite.cpp lldb/source/Core/Declaration.cpp lldb/source/Symbol/CompileUnit.cpp lldb/source/Target/StackFrameList.cpp lldb/source/Target/StopInfo.cpp lldb/source/Target/Thread.cpp lldb/source/Target/ThreadPlanStepInRange.cpp lldb/source/Target/ThreadPlanStepOverRange.cpp lldb/test/API/functionalities/inline-stepping/calling.cpp
``````````
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/lldb/include/lldb/Breakpoint/BreakpointLocation.h b/lldb/include/lldb/Breakpoint/BreakpointLocation.h
index f9c258daf1..552fafab97 100644
--- a/lldb/include/lldb/Breakpoint/BreakpointLocation.h
+++ b/lldb/include/lldb/Breakpoint/BreakpointLocation.h
@@ -283,7 +283,7 @@ public:
/// Returns the breakpoint location ID.
lldb::break_id_t GetID() const { return m_loc_id; }
-
+
// Set the line entry that should be shown to users for this location.
// It is up to the caller to verify that this is a valid entry to show.
// The current use of this is to distinguish among line entries from a
@@ -291,7 +291,7 @@ public:
void SetPreferredLineEntry(const LineEntry &line_entry) {
m_preferred_line_entry = line_entry;
}
-
+
const std::optional<LineEntry> GetPreferredLineEntry() {
return m_preferred_line_entry;
}
@@ -319,7 +319,7 @@ protected:
/// It also takes care of decrementing the ignore counters.
/// If it returns false we should continue, otherwise stop.
bool IgnoreCountShouldStop();
-
+
// If this location knows that the virtual stack frame it represents is
// not frame 0, return the suggested stack frame instead. This will happen
// when the location's address contains a "virtual inlined call stack" and the
@@ -393,13 +393,14 @@ private:
lldb::break_id_t m_loc_id; ///< Breakpoint location ID.
StoppointHitCounter m_hit_counter; ///< Number of times this breakpoint
/// location has been hit.
- std::optional<LineEntry> m_preferred_line_entry; // If this exists, use it to print the stop
- // description rather than the LineEntry
- // m_address resolves to directly. Use this
- // for instance when the location was given
- // somewhere in the virtual inlined call
- // stack since the Address always resolves
- // to the lowest entry in the stack.
+ std::optional<LineEntry>
+ m_preferred_line_entry; // If this exists, use it to print the stop
+ // description rather than the LineEntry
+ // m_address resolves to directly. Use this
+ // for instance when the location was given
+ // somewhere in the virtual inlined call
+ // stack since the Address always resolves
+ // to the lowest entry in the stack.
void SetShouldResolveIndirectFunctions(bool do_resolve) {
m_should_resolve_indirect_functions = do_resolve;
diff --git a/lldb/include/lldb/Breakpoint/BreakpointSite.h b/lldb/include/lldb/Breakpoint/BreakpointSite.h
index 30cb5a80b9..7b3f7be236 100644
--- a/lldb/include/lldb/Breakpoint/BreakpointSite.h
+++ b/lldb/include/lldb/Breakpoint/BreakpointSite.h
@@ -169,7 +169,7 @@ public:
///
/// \see lldb::DescriptionLevel
void GetDescription(Stream *s, lldb::DescriptionLevel level);
-
+
// This runs through all the breakpoint locations owning this site and returns
// the greatest of their suggested stack frame indexes. This only handles
// inlined stack changes.
diff --git a/lldb/include/lldb/Target/StopInfo.h b/lldb/include/lldb/Target/StopInfo.h
index d997e0fd6f..45beac129e 100644
--- a/lldb/include/lldb/Target/StopInfo.h
+++ b/lldb/include/lldb/Target/StopInfo.h
@@ -79,13 +79,14 @@ public:
/// This gives the StopInfo a chance to suggest a stack frame to select.
/// Passing true for inlined_stack will request changes to the inlined
- /// call stack. Passing false will request changes to the real stack
+ /// call stack. Passing false will request changes to the real stack
/// frame. The inlined stack gets adjusted before we call into the thread
/// plans so they can reason based on the correct values. The real stack
/// adjustment is handled after the frame recognizers get a chance to adjust
/// the frame.
- virtual std::optional<uint32_t> GetSuggestedStackFrameIndex(bool inlined_stack) {
- return {};
+ virtual std::optional<uint32_t>
+ GetSuggestedStackFrameIndex(bool inlined_stack) {
+ return {};
}
virtual bool IsValidForOperatingSystemThread(Thread &thread) { return true; }
diff --git a/lldb/include/lldb/Target/ThreadPlanStepInRange.h b/lldb/include/lldb/Target/ThreadPlanStepInRange.h
index 6bd79e1d28..f2cb108530 100644
--- a/lldb/include/lldb/Target/ThreadPlanStepInRange.h
+++ b/lldb/include/lldb/Target/ThreadPlanStepInRange.h
@@ -80,8 +80,8 @@ private:
bool m_step_past_prologue; // FIXME: For now hard-coded to true, we could put
// a switch in for this if there's
// demand for that.
- LazyBool m_virtual_step; // true if we've just done a "virtual step", i.e. just
- // moved the inline stack depth.
+ LazyBool m_virtual_step; // true if we've just done a "virtual step", i.e.
+ // just moved the inline stack depth.
ConstString m_step_into_target;
ThreadPlanStepInRange(const ThreadPlanStepInRange &) = delete;
const ThreadPlanStepInRange &
diff --git a/lldb/source/Breakpoint/BreakpointLocation.cpp b/lldb/source/Breakpoint/BreakpointLocation.cpp
index 61fe467987..7e002b9ba4 100644
--- a/lldb/source/Breakpoint/BreakpointLocation.cpp
+++ b/lldb/source/Breakpoint/BreakpointLocation.cpp
@@ -508,7 +508,7 @@ void BreakpointLocation::GetDescription(Stream *s,
s->PutCString("re-exported target = ");
else
s->PutCString("where = ");
-
+
// If there's a preferred line entry for printing, use that.
bool show_function_info = true;
if (GetPreferredLineEntry()) {
@@ -520,7 +520,8 @@ void BreakpointLocation::GetDescription(Stream *s,
show_function_info = false;
}
sc.DumpStopContext(s, m_owner.GetTarget().GetProcessSP().get(), m_address,
- false, true, false, show_function_info, show_function_info, show_function_info);
+ false, true, false, show_function_info,
+ show_function_info, show_function_info);
} else {
if (sc.module_sp) {
s->EOL();
@@ -670,7 +671,7 @@ void BreakpointLocation::SendBreakpointLocationChangedEvent(
}
}
-std::optional<uint32_t> BreakpointLocation::GetSuggestedStackFrameIndex() {
+std::optional<uint32_t> BreakpointLocation::GetSuggestedStackFrameIndex() {
if (!GetPreferredLineEntry())
return {};
LineEntry preferred = *GetPreferredLineEntry();
@@ -682,12 +683,13 @@ std::optional<uint32_t> BreakpointLocation::GetSuggestedStackFrameIndex() {
// case.
if (!LineEntry::Compare(sc.line_entry, preferred))
return {};
-
+
if (!sc.block)
return {};
// Blocks have their line info in Declaration form, so make one here:
- Declaration preferred_decl(preferred.GetFile(), preferred.line, preferred.column);
+ Declaration preferred_decl(preferred.GetFile(), preferred.line,
+ preferred.column);
uint32_t depth = 0;
Block *inlined_block = sc.block->GetContainingInlinedBlock();
@@ -695,8 +697,8 @@ std::optional<uint32_t> BreakpointLocation::GetSuggestedStackFrameIndex() {
// If we've moved to a block that this isn't the start of, that's not
// our inlining info or call site, so we can stop here.
Address start_address;
- if (!inlined_block->GetStartAddress(start_address)
- || start_address != m_address)
+ if (!inlined_block->GetStartAddress(start_address) ||
+ start_address != m_address)
return {};
const InlineFunctionInfo *info = inlined_block->GetInlinedFunctionInfo();
@@ -710,7 +712,6 @@ std::optional<uint32_t> BreakpointLocation::GetSuggestedStackFrameIndex() {
depth++;
}
return {};
-
}
void BreakpointLocation::SwapLocation(BreakpointLocationSP swap_from) {
diff --git a/lldb/source/Breakpoint/BreakpointResolver.cpp b/lldb/source/Breakpoint/BreakpointResolver.cpp
index 465fc387aa..688dffa02e 100644
--- a/lldb/source/Breakpoint/BreakpointResolver.cpp
+++ b/lldb/source/Breakpoint/BreakpointResolver.cpp
@@ -340,17 +340,17 @@ void BreakpointResolver::AddLocation(SearchFilter &filter,
}
BreakpointLocationSP bp_loc_sp(AddLocation(line_start));
- // If the address that we resolved the location to returns a different
+ // If the address that we resolved the location to returns a different
// LineEntry from the one in the incoming SC, we're probably dealing with an
// inlined call site, so set that as the preferred LineEntry:
LineEntry resolved_entry;
- if (!skipped_prologue && bp_loc_sp &&
+ if (!skipped_prologue && bp_loc_sp &&
line_start.CalculateSymbolContextLineEntry(resolved_entry) &&
LineEntry::Compare(resolved_entry, sc.line_entry)) {
- // FIXME: The function name will also be wrong here. Do we need to record
- // that as well, or can we figure that out again when we report this
- // breakpoint location.
- bp_loc_sp->SetPreferredLineEntry(sc.line_entry);
+ // FIXME: The function name will also be wrong here. Do we need to record
+ // that as well, or can we figure that out again when we report this
+ // breakpoint location.
+ bp_loc_sp->SetPreferredLineEntry(sc.line_entry);
}
if (log && bp_loc_sp && !GetBreakpoint()->IsInternal()) {
StreamString s;
diff --git a/lldb/source/Symbol/CompileUnit.cpp b/lldb/source/Symbol/CompileUnit.cpp
index f4c61d6ec1..666e682ff5 100644
--- a/lldb/source/Symbol/CompileUnit.cpp
+++ b/lldb/source/Symbol/CompileUnit.cpp
@@ -251,8 +251,10 @@ void CompileUnit::ResolveSymbolContext(
SymbolContextItem resolve_scope, SymbolContextList &sc_list,
RealpathPrefixes *realpath_prefixes) {
const FileSpec file_spec = src_location_spec.GetFileSpec();
- const uint32_t line = src_location_spec.GetLine().value_or(LLDB_INVALID_LINE_NUMBER);
- const uint32_t column_num = src_location_spec.GetColumn().value_or(LLDB_INVALID_COLUMN_NUMBER);
+ const uint32_t line =
+ src_location_spec.GetLine().value_or(LLDB_INVALID_LINE_NUMBER);
+ const uint32_t column_num =
+ src_location_spec.GetColumn().value_or(LLDB_INVALID_COLUMN_NUMBER);
const bool check_inlines = src_location_spec.GetCheckInlines();
// First find all of the file indexes that match our "file_spec". If
@@ -312,42 +314,45 @@ void CompileUnit::ResolveSymbolContext(
line_idx = line_table->FindLineEntryIndexByFileIndex(
0, file_indexes, src_location_spec, &line_entry);
}
-
+
// If we didn't manage to find a breakpoint that matched the line number
- // requested, that might be because it is only an inline call site, and
+ // requested, that might be because it is only an inline call site, and
// doesn't have a line entry in the line table. Scan for that here.
//
// We are making the assumption that if there was an inlined function it will
- // contribute at least 1 non-call-site entry to the line table. That's handy
- // because we don't move line breakpoints over function boundaries, so if we
+ // contribute at least 1 non-call-site entry to the line table. That's handy
+ // because we don't move line breakpoints over function boundaries, so if we
// found a hit, and there were also a call site entry, it would have to be in
// the function containing the PC of the line table match. That way we can
// limit the call site search to that function.
// We will miss functions that ONLY exist as a call site entry.
- if (line_entry.IsValid() && (line_entry.line != line || line_entry.column != column_num)
- && resolve_scope & eSymbolContextLineEntry && check_inlines) {
+ if (line_entry.IsValid() &&
+ (line_entry.line != line || line_entry.column != column_num) &&
+ resolve_scope & eSymbolContextLineEntry && check_inlines) {
// We don't move lines over function boundaries, so the address in the
// line entry will be the in function that contained the line that might
// be a CallSite, and we can just iterate over that function to find any
// inline records, and dig up their call sites.
Address start_addr = line_entry.range.GetBaseAddress();
Function *function = start_addr.CalculateSymbolContextFunction();
-
+
Declaration sought_decl(file_spec, line, column_num);
// We use this recursive function to descend the block structure looking
// for a block that has this Declaration as in it's CallSite info.
// This function recursively scans the sibling blocks of the incoming
// block parameter.
- std::function<void(Block&)> examine_block =
- [&sought_decl, &sc_list, &src_location_spec, resolve_scope, &examine_block] (Block &block) -> void {
+ std::function<void(Block &)> examine_block =
+ [&sought_decl, &sc_list, &src_location_spec, resolve_scope,
+ &examine_block](Block &block) -> void {
// Iterate over the sibling child blocks of the incoming block.
Block *sibling_block = block.GetFirstChild();
while (sibling_block) {
// We only have to descend through the regular blocks, looking for
// immediate inlines, since those are the only ones that will have this
// callsite.
- const InlineFunctionInfo *inline_info = sibling_block->GetInlinedFunctionInfo();
+ const InlineFunctionInfo *inline_info =
+ sibling_block->GetInlinedFunctionInfo();
if (inline_info) {
// If this is the call-site we are looking for, record that:
// We need to be careful because the call site from the debug info
@@ -355,13 +360,14 @@ void CompileUnit::ResolveSymbolContext(
// it.
Declaration found_decl = inline_info->GetCallSite();
uint32_t sought_column = sought_decl.GetColumn();
- if (found_decl.FileAndLineEqual(sought_decl)
- && (sought_column == LLDB_INVALID_COLUMN_NUMBER
- || sought_column == found_decl.GetColumn())) {
+ if (found_decl.FileAndLineEqual(sought_decl) &&
+ (sought_column == LLDB_INVALID_COLUMN_NUMBER ||
+ sought_column == found_decl.GetColumn())) {
// If we found a call site, it belongs not in this inlined block,
// but in the parent block that inlined it.
Address parent_start_addr;
- if (sibling_block->GetParent()->GetStartAddress(parent_start_addr)) {
+ if (sibling_block->GetParent()->GetStartAddress(
+ parent_start_addr)) {
SymbolContext sc;
parent_start_addr.CalculateSymbolContext(&sc, resolve_scope);
// Now swap out the line entry for the one we found.
@@ -373,31 +379,32 @@ void CompileUnit::ResolveSymbolContext(
// call site we found actually matches the location.
if (src_location_spec.GetExactMatch()) {
matches_spec = false;
- if ((src_location_spec.GetFileSpec() == sc.line_entry.GetFile())
- && (src_location_spec.GetLine() &&
- *src_location_spec.GetLine() == call_site_line.line)
- && (src_location_spec.GetColumn() &&
- *src_location_spec.GetColumn() == call_site_line.column))
- matches_spec = true;
+ if ((src_location_spec.GetFileSpec() ==
+ sc.line_entry.GetFile()) &&
+ (src_location_spec.GetLine() &&
+ *src_location_spec.GetLine() == call_site_line.line) &&
+ (src_location_spec.GetColumn() &&
+ *src_location_spec.GetColumn() == call_site_line.column))
+ matches_spec = true;
}
- if (matches_spec &&
+ if (matches_spec &&
sibling_block->GetRangeAtIndex(0, call_site_line.range)) {
- SymbolContext call_site_sc(sc.target_sp, sc.module_sp, sc.comp_unit,
- sc.function, sc.block, &call_site_line,
- sc.symbol);
+ SymbolContext call_site_sc(sc.target_sp, sc.module_sp,
+ sc.comp_unit, sc.function, sc.block,
+ &call_site_line, sc.symbol);
sc_list.Append(call_site_sc);
}
}
}
}
-
+
// Descend into the child blocks:
examine_block(*sibling_block);
// Now go to the next sibling:
- sibling_block = sibling_block->GetSibling();
+ sibling_block = sibling_block->GetSibling();
}
};
-
+
if (function) {
// We don't need to examine the function block, it can't be inlined.
Block &func_block = function->GetBlock(true);
@@ -405,7 +412,7 @@ void CompileUnit::ResolveSymbolContext(
}
// If we found entries here, we are done. We only get here because we
// didn't find an exact line entry for this line & column, but if we found
- // an exact match from the call site info that's strictly better than
+ // an exact match from the call site info that's strictly better than
// continuing to look for matches further on in the file.
// FIXME: Should I also do this for "call site line exists between the
// given line number and the later line we found in the line table"? That's
diff --git a/lldb/source/Target/StackFrameList.cpp b/lldb/source/Target/StackFrameList.cpp
index cda360baed..94a381edd5 100644
--- a/lldb/source/Target/StackFrameList.cpp
+++ b/lldb/source/Target/StackFrameList.cpp
@@ -85,14 +85,14 @@ void StackFrameList::ResetCurrentInlinedDepth() {
return;
std::lock_guard<std::recursive_mutex> guard(m_mutex);
-
+
m_current_inlined_pc = LLDB_INVALID_ADDRESS;
m_current_inlined_depth = UINT32_MAX;
StopInfoSP stop_info_sp = m_thread.GetStopInfo();
if (!stop_info_sp)
return;
-
+
bool inlined = true;
auto inline_depth = stop_info_sp->GetSuggestedStackFrameIndex(inlined);
// We're only adjusting the inlined stack here.
@@ -745,27 +745,28 @@ void StackFrameList::SelectMostRelevantFrame() {
bool found_relevant = false;
if (stop_info_sp) {
// Here we're only asking the stop info if it wants to adjust the real stack
- // index. We have to ask about the m_inlined_stack_depth in
+ // index. We have to ask about the m_inlined_stack_depth in
// Thread::ShouldStop since the plans need to reason with that info.
bool inlined = false;
- std::optional<uint32_t> stack_opt = stop_info_sp->GetSuggestedStackFrameIndex(inlined);
+ std::optional<uint32_t> stack_opt =
+ stop_info_sp->GetSuggestedStackFrameIndex(inlined);
if (stack_opt) {
stack_idx = *stack_opt;
found_relevant = true;
}
}
-
+
frame_sp = GetFrameAtIndex(stack_idx);
if (!frame_sp)
- LLDB_LOG(log, "Stop info suggested relevant frame {0} but it didn't exist",
+ LLDB_LOG(log, "Stop info suggested relevant frame {0} but it didn't exist",
stack_idx);
else if (found_relevant)
LLDB_LOG(log, "Setting selected frame from stop info to {0}", stack_idx);
// Note, we don't have to worry about "inlined" frames here, because we've
- // already calculated the inlined frame in Thread::ShouldStop, and
+ // already calculated the inlined frame in Thread::ShouldStop, and
// SetSelectedFrame will take care of that adjustment for us.
SetSelectedFrame(frame_sp.get());
-
+
if (!found_relevant)
LLDB_LOG(log, "No relevant frame!");
}
diff --git a/lldb/source/Target/StopInfo.cpp b/lldb/source/Target/StopInfo.cpp
index 8ba46366c8..aa9c97a615 100644
--- a/lldb/source/Target/StopInfo.cpp
+++ b/lldb/source/Target/StopInfo.cpp
@@ -247,7 +247,8 @@ public:
return m_description.c_str();
}
- std::optional<uint32_t> GetSuggestedStackFrameIndex(bool inlined_stack) override {
+ std::optional<uint32_t>
+ GetSuggestedStackFrameIndex(bool inlined_stack) override {
if (!inlined_stack)
return {};
@@ -258,10 +259,10 @@ public:
thread_sp->GetProcess()->GetBreakpointSiteList().FindByID(m_value));
if (!bp_site_sp)
return {};
-
+
return bp_site_sp->GetSuggestedStackFrameIndex();
}
-
+
protected:
bool ShouldStop(Event *event_ptr) override {
// This just reports the work done by PerformAction or the synchronous
@@ -1180,9 +1181,9 @@ public:
else
return m_description.c_str();
}
-
- std::optional<uint32_t> GetSuggestedStackFrameIndex(bool inlined_stack) override
- {
+
+ std::optional<uint32_t>
+ GetSuggestedStackFrameIndex(bool inlined_stack) override {
// Trace only knows how to adjust inlined stacks:
if (!inlined_stack)
return {};
@@ -1201,7 +1202,7 @@ public:
if (!block_ptr->GetRangeContainingAddress(pc_address, containing_range) ||
pc_address != containing_range.GetBaseAddress())
return {};
-
+
int num_inlined_functions = 0;
for (Block *container_ptr = block_ptr->GetInlinedParent();
@@ -1218,7 +1219,6 @@ public:
inlined_stack = true;
return num_inlined_functions + 1;
}
-
};
// StopInfoException
diff --git a/lldb/source/Target/Thread.cpp b/lldb/source/Target/Thread.cpp
index d13013c185..6c22b50d3b 100644
--- a/lldb/source/Target/Thread.cpp
+++ b/lldb/source/Target/Thread.cpp
@@ -620,7 +620,7 @@ void Thread::WillStop() {
void Thread::SetupForResume() {
if (GetResumeState() != eStateSuspended) {
// First check whether this thread is going to "actually" resume at all.
- // For instance, if we're stepping from one level to the next of an
+ // For instance, if we're stepping from one level to the next of an
// virtual inlined call stack, we just change the inlined call stack index
// without actually running this thread. In that case, for this thread we
// shouldn't push a step over breakpoint plan or do that work.
diff --git a/lldb/source/Target/ThreadPlanStepInRange.cpp b/lldb/source/Target/ThreadPlanStepInRange.cpp
index 5319afb4ed..325a706199 100644
--- a/lldb/source/Target/ThreadPlanStepInRange.cpp
+++ b/lldb/source/Target/ThreadPlanStepInRange.cpp
@@ -486,7 +486,7 @@ bool ThreadPlanStepInRange::DoWillResume(lldb::StateType resume_state,
return true;
}
-bool ThreadPlanStepInRange::IsVirtualStep() {
+bool ThreadPlanStepInRange::IsVirtualStep() {
if (m_virtual_step == eLazyBoolCalculate) {
Thread &thread = GetThread();
if (thread.GetCurrentInlinedDepth() == UINT32_MAX)
@@ -494,5 +494,5 @@ bool ThreadPlanStepInRange::IsVirtualStep() {
else
m_virtual_step = eLazyBoolYes;
}
- return m_virtual_step == eLazyBoolYes;
+ return m_virtual_step == eLazyBoolYes;
}
diff --git a/lldb/test/API/functionalities/inline-stepping/calling.cpp b/lldb/test/API/functionalities/inline-stepping/calling.cpp
index 0009388bd8..d7ee56b3c0 100644
--- a/lldb/test/API/functionalities/inline-stepping/calling.cpp
+++ b/lldb/test/API/functionalities/inline-stepping/calling.cpp
@@ -15,9 +15,9 @@ inline void inline_trivial_2 () __attribute__((always_inline));
// These three should share the same initial pc so we can test
// virtual inline stepping.
-inline void caller_trivial_inline_1 () __attribute__((always_inline));
-inline void caller_trivial_inline_2 () __attribute__((always_inline));
-inline void caller_trivial_inline_3 () __attribute__((always_inline));
+inline void caller_trivial_inline_1() __attribute__((always_inline));
+inline void caller_trivial_inline_2() __attribute__((always_inline));
+inline void caller_trivial_inline_3() __attribute__((always_inline));
void caller_trivial_1 ();
void caller_trivial_2 ();
@@ -88,24 +88,18 @@ caller_trivial_2 ()
// When you call caller_trivial_inline_1, the inlined call-site
// should share a PC with all three of the following inlined
// functions, so we can exercise "virtual inline stepping".
-void
-caller_trivial_inline_1 ()
-{
- caller_trivial_inline_2(); // In caller_trivial_inline_1.
- inline_value += 1;
+void caller_trivial_inline_1() {
+ caller_trivial_inline_2(); // In caller_trivial_inline_1.
+ inline_value += 1;
}
-void
-caller_trivial_inline_2 ()
-{
- caller_trivial_inline_3(); // In caller_trivial_inline_2.
- inline_value += 1;
+void caller_trivial_inline_2() {
+ caller_trivial_inline_3(); // In caller_trivial_inline_2.
+ inline_value += 1;
}
-void
-caller_trivial_inline_3 ()
-{
- inline_value += 1; // In caller_trivial_inline_3.
+void caller_trivial_inline_3() {
+ inline_value += 1; // In caller_trivial_inline_3.
}
void
@@ -162,6 +156,6 @@ main (int argc, char **argv)
max_value(std::string("abc"), std::string("0022")); // Call max_value specialized
caller_trivial_inline_1(); // At caller_trivial_inline_1.
-
+
return 0; // About to return from main.
}
``````````
</details>
https://github.com/llvm/llvm-project/pull/112939
More information about the lldb-commits
mailing list