Significant changes since last LWG review are marked with blue.
Show deleted lines from P0881R5.
In the current working draft [N4741] there is no way to get, store and decode the current call sequence. Such call sequences are useful for debugging and post mortem debugging. They are popular in other programming languages (like Java, C#, Python).
Pretty often assertions can't describe the whole picture of a bug and do not provide enough information to locate the problem. For example, you can see the following message on out-of-range access:
boost/array.hpp:123: T& boost::array<T, N>::operator[](boost::array<T, N>::size_type): Assertion '(i < N)&&("out of range")' failed. Aborted (core dumped)
That's not enough information in the assert message to locate the problem without debugger.
This paper proposes classes that could simplify debugging and may change the assertion message into the following:
Expression 'i < N' is false in function 'T& boost::array<T, N>::operator[](boost::array<T, N>::size_type)': out of range. Backtrace: 0# boost::assertion_failed_msg(char const*, char const*, char const*, char const*, long) at ../example/assert_handler.cpp:39 1# boost::array<int, 5ul>::operator[](unsigned long) at ../../../boost/array.hpp:124 2# bar(int) at ../example/assert_handler.cpp:17 3# foo(int) at ../example/assert_handler.cpp:25 4# bar(int) at ../example/assert_handler.cpp:17 5# foo(int) at ../example/assert_handler.cpp:25 6# main at ../example/assert_handler.cpp:54 7# 0x00007F991FD69F45 in /lib/x86_64-linux-gnu/libc.so.6 8# 0x0000000000401139
The design is based on the Boost.Stacktrace library, a popular library that does not depend on any non-standard library components.
Note about signal safety: this proposal does not attempt to provide a signal-safe solution for capturing and decoding stacktraces.
Such functionality currently is not implementable on some of the popular platforms. However, the paper attempts to provide extensible solution, that may be made signal safe some day
by providing a signal safe allocator and changing the stacktrace
implementation details.
Note on performance: during Boost.Stacktrace development phase many users requested a fast way to store stacktrace, without decoding the function names. This functionality is preserved in the paper.
All the stack_frame
functions and constructors are lazy and won't decode the pointer information if there was no explicit request from class user.
Note on allocations: initial (pre-Boost) implementations of Boost.Stacktrace were not using allocator and all the frames were placed inside a fixed size internal storage. That was a mistake! Sometimes the most important information is located at the bottom of the stack. For example if you run Boost.Test, then the test name will be located low on the stack. With a fixed size storage the bottom of the stack could be lost along with the information.
Current design assumes that by default users wish to see the whole stack and OK with dynamic allocations, because do not construct stacktrace
in performance critical places.
For those users, who wish to use stacktrace
on a hot path or in embedded environments basic_stacktrace
allows to provide a custom allocator that allocates
on the stack or in some other place, where users thinks it is appropriate.
Custom allocators support for functions like to_string
, source_file
and description
is not provided. Those functions usually require platform specific
allocations, system calls and a lot of CPU intensive work. Custom allocator does not provide benefits for those functions as the platform specific operations take an order of magnitude more time than the allocation.
Note on returning std::string
and not having noexcept
on stack_frame::source_line()
:
Unfortunately this is a necessarity on some platforms, where getting source line requires allocating or where source
file name returned into a storage
provided by user.
Note on expected implementation:
We assume that Standard Library implementations would allow to disable/enable gathering stacktraces by a compiler switch that does not require recompiling the whole project.
In other words, we expect to see a compiler option like -fno-stacktrace
or libstacktrace/lib_stacktrace_noop
libraries with the same ABI that would
force the constructor of the basic_stacktrace
to do nothing. This feature is implemented in Boost.Stacktrace and is highly requested in big projects.
Should stacktrace
be a class or a function?
class | function |
---|---|
struct promise_type {
std::vector<stack_frame> frames;
void append(const stacktrace& s) {
frames.insert(frames.end(), s.begin(), s.end());
}
void print() {
for (int i=0; auto& frame: frames) {
std::cout << i++ << " " << frame;
}
}
};
|
struct promise_type {
std::vector<stack_frame> frames;
void append(const std::vector<stack_frame>& s) {
frames.insert(frames.end(), s.begin(), s.end());
}
void print() {
std::cout << frames;
}
};
|
class stacktrace { small_vector<stack_frame> frames_; platform-specific-cache-of-internals; public: operator bool() const noexcept; // almost all the vector interface }; |
template<class Allocator = allocator<stack_frame>> vector<stack_frame, Allocator> stacktrace(const Allocator& alloc = Allocator{}) noexcept; template<class Allocator = allocator<stack_frame>> vector<stack_frame, Allocator> stacktrace(size_type skip, size_type max_depth, const Allocator& alloc = Allocator{}) noexcept; |
template<class Allocator> string to_string(const basic_stacktrace<Allocator>& st); template<class charT, class traits, class Allocator> basic_ostream<charT, traits>& operator<< (basic_ostream<charT, traits>& os, const basic_stacktrace<Allocator>& st); |
template<class Allocator> string to_string(const vector<stack_frame, Allocator>& st); template<class charT, class traits, class Allocator> basic_ostream<charT, traits>& operator<< (basic_ostream<charT, traits>& os, const vector<stack_frame, Allocator>& st); |
stacktrace s;
if (s) {
std::cout << "backtrace: " << s;
}
|
auto s = stacktrace();
if (!s.empty()) {
std::cout << "backtrace: " << s;
} |
LEWG decided to leave it a separate type: "Prefer stacktrace as a type rather than `vector`." SF:0, F:3, N:5, A:0, SA:0
Kona questions to LEWG:
stack_frame
is actually a pointer to some instruction. It's a static frame, not a dynamic one (the latter including the local variables and coroutines etc). Should stack_frame
be renamed into
? Also note that the name invocation_info stacktrace::entrystack_frame
could be usable in the coroutines and fibers worlds.
LEWG: Naming for stack_frame:
2 stack_frame
3 invocation_info
9 stacktrace::entry
3 stacktrace::frame
5 stacktrace_entry
1 stacktrace_frame
2 frame_descriptor
4 call_info
2 call_descriptor
2 frame_info.
stacktrace::entry wins (Would be backtrace::entry if rename occurs).
LEWG: Nest class inside stacktrace: SF 4 F 3 N 1 A 3 SA 1. Not concensus, status quo is against.
If we now have invocation_info
, should stacktrace
be renamed into backtrace
? Note that there is a ::backtrace
function on GNU Linux.
LEWG: stacktrace vs backtrace: SS 1 S 4 N 2 B 3 SB 3. Author decides.
Querying information about the frame is a heavy operation. To be consistent with the Filesystem approach should the query functions become a free functions?
LEWG: Leave expensive ops as member functions. Unanimous consent.
There is a difference between "physical" and "logical" invocations. In other words std::stacktrace
may have size N
, while the implementation could decode N
stack_frames
into N+X
records in the to_string
function. Is LEWG OK with shipping the current design that gives no way to retrieve the logical invocations size?
LEWG: We are OK with the fact that N physical entries can become N+X logical entries after decoding (because of expanding inline functions). Unanimous consent.
stack_frame | invocation_info |
---|---|
unordered_map<stack_frame, string> cache; // ... for (stack_frame f : stacktrace{}) { auto it = cache.find(f); if (it == cache.end()) { it = cache.emplace(f, f.description())->first; } cerr << it->second; } |
unordered_map<invocation_info, string> cache; // ... for (invocation_info f : backtrace{}) { auto it = cache.find(f); if (it == cache.end()) { it = cache.emplace(f, description(f))->first; } cerr << it->second; } |
void assertion_failed_msg(char const* expr) { std::stacktrace st(1, 1); stack_frame inf = st[0]; std::cerr << "Expression '" << expr << "' is false in '" << inf.description() << " at " << inf.source_file() << ':' << inf.source_line() << ".\n"; std::abort(); } |
void assertion_failed_msg(char const* expr) { std::backtrace st(1, 1); invocation_info inf = st[0]; std::cerr << "Expression '" << expr << "' is false in '" << description(inf) << " at " << source_file(inf) << ':' << source_line(inf) << ".\n"; std::abort(); } |
struct promise_type { std::vector<stack_frame> trace; void append(const stacktrace& s) { trace.insert(trace.end(), s.begin(), s.end()); } // ... }; |
struct promise_type { std::vector<invocation_info> trace; void append(const backtrace& s) { trace.insert(trace.end(), s.begin(), s.end()); } // ... }; |
If the invocation_info
and stack_frame
are both not acceptable, the following input could be used to preview the above table with other names (like call_info
,trace_info
, stacktrace::record
...):
LEWG:
stack_frame
constructors from function pointers and stack_frame::native_ptr_t
alias.rbegin
like functions for basic_stacktrace
, so now basic_stacktrace
satisfies the requirements
of an allocator-aware container, of a sequence container and reversible container except that only operations defined for const-qualified sequence containers are
supported and that the semantics of comparison functions and default constructor are different from those required for a container.LEWG was OK with the above changes.
SG16:
stack_frame::source_file()
and encodings.SG16 discussed a number of options including the possibility of source_file()
returning std::filesystem::path
. SG16 converged on the
following recommendation: "Align behavior with source_location; remove wording regarding
conversion; string contents are implementation defined.
". No objection to unanimous consent.
CWG question to LEWG:
stack_frame::address()
function should return instruction pointer, or stack address (that may have contained the instruction pointer), or both? LEWG in favour of instruction pointer: "stack_frame::address()
should return (something like) the instruction pointer (only)." SF:4, F:7, N:0, A:0, SA:0.
Points of special interest for CWG:
Key features that should be preserved by implementations:
stacktrace
.stacktrace_entry::description()
should return a demangled function signature if possible.to_string(stacktrace)
should query information from debug symbols, symbol export tables and any other sources, returning demangled signatures if possible.to_string(stacktrace)
.stacktrace
should be usable in contract violation handler, coroutines, handler functions [handler.functions], parallel algorithms, etc.[Note for editor: Add the header <stacktrace> into the Table 19 in [headers] - end note]
This subclause describes components that C++ programs may use to store the stacktrace of the current thread of execution and query information about the stored stacktrace at runtime.
The invocation sequence of the current evaluation x0
in the current thread of execution is a sequence (x0, ..., xn)
of evaluations such that, for i >= 0
, xi
is within the function invocation xi+1
(6.8.1 [intro.execution]).
A stacktrace is an approximate representation of an invocation sequence and consists of stacktrace entries. A stacktrace entry represents an evaluation in a stacktrace.
namespace std { // 20.?.3, class stacktrace_entry class stacktrace_entry; // 20.?.4, class basic_stacktrace template<class Allocator> class basic_stacktrace; // basic_stacktrace typedef names using stacktrace = basic_stacktrace<allocator<stacktrace_entry>>; // 20.?.5, non-member functions template<class Allocator> void swap(basic_stacktrace<Allocator>& a, basic_stacktrace<Allocator>& b); template<class Allocator> string to_string(const basic_stacktrace<Allocator>& st); string to_string(const stacktrace_entry& f); template<class charT, class traits, class Allocator> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const basic_stacktrace<Allocator>& st); template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const stacktrace_entry& f); // 20.?.6, hash support template<class T> struct hash; template<> struct hash<stacktrace_entry>; template<class Allocator> struct hash<basic_stacktrace<Allocator>>; }
namespace std { class stacktrace_entry { public: using native_handle_type = implementation-defined; // 20.?.3.1, constructors constexpr stacktrace_entry() noexcept; constexpr stacktrace_entry(const stacktrace_entry& other) noexcept = default; constexpr stacktrace_entry& operator=(const stacktrace_entry& other) noexcept = default; ~stacktrace_entry() = default; // 20.?.3.2, observers constexpr implementation-defined native_handle() const noexcept; constexpr explicit operator bool() const noexcept; // 20.?.3.3, query string description() const; string source_file() const; uint_least32_t source_line() const; // 20.?.3.4, comparison friend constexpr bool operator==(const stacktrace_entry& x, const stacktrace_entry& y) noexcept; friend constexpr strong_ordering operator<=>(const stacktrace_entry& x, const stacktrace_entry& y) noexcept; }; }
An object of class stacktrace_entry
represents a stacktrace entry and provides operations for querying information about it.
constexpr stacktrace_entry() noexcept;
stacktrace_entry
object that does not represent a stacktrace entry.constexpr native_handle_typeimplementation-defined native_handle() const noexcept;
*this
.native_handle()
function for the same stacktrace_entry
object return identical values.constexpr explicit operator bool() const noexcept;
true
if and only if *this
represents a stacktrace entry.[Note: All the stacktrace_entry
query functions treat errors other than memory allocation errors as "no information available"
and do not throw in that case. - end note]
string description() const;
*this
, or an empty string.bad_alloc
if memory for the internal data structures or the resulting string cannot be allocated.string source_file() const;
*this
, or an empty string.bad_alloc
if memory for the internal data structures or the resulting string cannot be allocated.uint_least32_t source_line() const;
0
, or a 1-based line number that lexically relates to the evaluation represented by *this
. If source_file
returns the presumed name of the source file, returns the presumed line number; if source_file
returns the actual name of the source file, returns the actual line number.bad_alloc
if memory for the internal data structures cannot be allocated.constexpr bool operator==(const stacktrace_entry& x, const stacktrace_entry& y) noexcept;
true
if and only if x
and y
represent the same stacktrace entry or neither x
nor y
represent a stacktrace entry.constexpr strong_ordering operator<=> (const stacktrace_entry& x, const stacktrace_entry& y) noexcept;
operator<=>
is a total ordering as described in [alg.sorting].basic_stacktrace
[stacktrace.basic.template]namespace std { template<class Allocator> class basic_stacktrace { public: using value_type = stacktrace_entry; using const_reference = const value_type&; using reference = value_type&; using const_iterator = implementation-defined; using iterator = const_iterator; using reverse_iterator = std::reverse_iterator<iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>; using difference_type = implementation-definedtypename iterator_traits<iterator>::difference_type; using size_type = implementation-definedtypename allocator_traits<Allocator>::size_type; using allocator_type = Allocator; // 20.?.4.1, construct/copy/destroy static basic_stacktrace current(const allocator_type& alloc = allocator_type()) noexcept; static basic_stacktrace current(size_type skip, const allocator_type& alloc = allocator_type()) noexcept; static basic_stacktrace current(size_type skip, size_type max_depth, const allocator_type& alloc = allocator_type()) noexcept; basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>); explicit basic_stacktrace(allocator_arg_t, const allocator_type& alloc) noexcept; basic_stacktrace(size_type skip, size_type max_depth, const allocator_type& alloc = allocator_type()) noexcept; basic_stacktrace(allocator_arg_t, const allocator_type& alloc, size_type skip, size_type max_depth) noexcept; basic_stacktrace(const basic_stacktrace& other) = default; basic_stacktrace(basic_stacktrace&& other) noexcept = default; basic_stacktrace(allocator_arg_t, const allocator_type& alloc, const basic_stacktrace& other, const allocator_type& alloc); basic_stacktrace(allocator_arg_t, const allocator_type& alloc, basic_stacktrace&& other, const allocator_type& alloc); basic_stacktrace& operator=(const basic_stacktrace& other) = default; basic_stacktrace& operator=(basic_stacktrace&& other) = default; ~basic_stacktrace() = default; // 20.?.4.2, observers allocator_type get_allocator() const noexcept; const_iterator begin() const noexcept; const_iterator end() const noexcept; const_reverse_iterator rbegin() const noexcept; const_reverse_iterator rend() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept; const_reverse_iterator crbegin() const noexcept; const_reverse_iterator crend() const noexcept; explicit operator bool() const noexcept; [[nodiscard]] bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept; const_reference operator[](size_type ) const; const_reference at(size_type ) const; // 20.?.4.3, comparisons template <class Allocator2> friend bool operator==(const basic_stacktrace& x, const basic_stacktrace< Allocator2 >& y) noexcept; template <class Allocator2> friend strong_ordering operator<=>(const basic_stacktrace& x, const basic_stacktrace< Allocator2 >& y) noexcept; // 20.?.4.4, modifiers void swap(basic_stacktrace& other); private: vector<value_type, allocator_type> frames_; // exposition only }; }
The basic_stacktrace
template class stores the stacktrace of the current thread of execution on construction and provides access to the stored stacktrace.
The class template basic_stacktrace
satisfies the requirements of an allocator-aware container, of a sequence
container and reversible container (21.2.1, 21.2.3) except that
static basic_stacktrace current(const allocator_type& alloc = allocator_type()) noexcept;
basic_stacktrace
object with frames_
storing the stacktrace of the current evaluation in the current thread of execution, or an empty basic_stacktrace
object if frames_
initialization failed. alloc
is passed to the constructor of the basic_stacktrace
object.frames_.front()
is the stacktrace_entry
representing approximately the current evaluation, and frames_.back()
is the stacktrace_entry
representing approximately the initial function of the current thread of execution. - end note]static basic_stacktrace current(size_type skip, const allocator_type& alloc = allocator_type()) noexcept;
t
be a stacktrace as-if obtained via basic_stacktrace::current(alloc)
. Let n
be t.size()
.basic_stacktrace
object with direct-non-list-initialized frames_
from arguments t.begin() + min(n, skip)
and t.end()
, or an empty basic_stacktrace
object if frames_
initialization failed.static basic_stacktrace current(size_type skip, size_type max_depth, const allocator_type& alloc = allocator_type()) noexcept;
t
be a stacktrace as-if obtained via basic_stacktrace::current(alloc)
. Let n
be t.size()
.skip <= skip + max_depth
.basic_stacktrace
object with direct-non-list-initialized frames_
from arguments t.begin() + min(n, skip)
and t.begin() + min(n, skip + max_depth)
, or an empty basic_stacktrace
object if frames_
initialization failed.basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>);
frames_
. alloc
is passed to the frames_
constructor. basic_stacktrace
.empty()
is true
.explicit basic_stacktrace(allocator_arg_t, const allocator_type& alloc) noexcept;
basic_stacktrace
. alloc
is passed to the frames_
constructor.empty()
is true
.basic_stacktrace(size_type skip, size_type max_depth, const allocator_type& alloc = allocator_type()) noexcept;
t
be a stacktrace as-if obtained via basic_stacktrace()
. Let n
be t.size()
.skip <= skip + max_depth
.frames_
with the arguments t.begin() + min(n, skip)
and t.begin() + min(n, skip + max_depth)
.basic_stacktrace(allocator_arg_t, const allocator_type& alloc, size_type skip, size_type max_depth) noexcept;
t
be a stacktrace as-if obtained via basic_stacktrace(alloc)
. Let n
be t.size()
.skip <= skip + max_depth
.frames_
with the arguments t.begin() + min(n, skip)
, t.begin() + min(n, skip + max_depth)
, and alloc
.basic_stacktrace(const basic_stacktrace& other) = default; basic_stacktrace(allocator_arg_t, const allocator_type& alloc, const basic_stacktrace& other, const allocator_type& alloc); basic_stacktrace(allocator_arg_t, const allocator_type& alloc, basic_stacktrace&& other, const allocator_type& alloc); basic_stacktrace& operator=(const basic_stacktrace& other) = default; basic_stacktrace& operator=(basic_stacktrace&& other) = default;
!*this
empty()
is true
on failed allocation.using const_iterator = implementation-defined;
iterator
.allocator_type get_allocator() const noexcept;
frames_.get_allocator()
.const_iterator begin() const noexcept; const_iterator cbegin() const noexcept;
frames_
. If empty()
is true
, then it returns the
same value as end()
frames_.cbegin()
.const_iterator end() const noexcept; const_iterator cend() const noexcept;
frames_.cend()
.const_iterator rbegin() const noexcept; const_iterator crbegin() const noexcept;
reverse_iterator(this->cend())
frames_.crbegin()
.const_iterator rend() const noexcept; const_iterator crend() const noexcept;
reverse_iterator(this->cbegin())
frames_.crend()
.explicit operator bool() const noexcept;
!frames_.empty()
.[[nodiscard]] bool empty() const noexcept;
frames_.empty()
.size_type size() const noexcept;
frames_.size()
.size_type max_size() const noexcept;
frames_.max_size()
.const_reference operator[](size_type frame_no) const;
frame_no < size()
.frames_[frame_no]
.const_reference at(size_type frame_no) const;
out_of_range
if frame_no >= size()
.frames_[frame_no]
.template <class Allocator2>
bool operator==(const basic_stacktrace& x, const basic_stacktrace< Allocator2 >& y) noexcept;
equal(x.begin(), x.end(), y.begin(), y.end())
template <class Allocator2>
strong_ordering operator<=>(const basic_stacktrace& x, const basic_stacktrace< Allocator2 >& y) noexcept;
x.size() <=> y.size()
if x.size() != y.size()
.
lexicographical_compare_3way(x.begin(), x.end(), y.begin(), other.end())
otherwise.void swap(basic_stacktrace& other);
*this
and other
.void swap(stacktrace_entry& a, stacktrace_entry& b) noexcept;
a.swap(b)
.template<class Allocator> void swap(basic_stacktrace<Allocator>& a, basic_stacktrace<Allocator>& b);
a.swap(b)
.template<class Allocator> string to_string(const basic_stacktrace<Allocator>& st);
st
.st.size()
. - end note]string to_string(const stacktrace_entry& f);
f
.source_file()
and source_line()
. - end note]template<class charT, class traits, class Allocator> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const basic_stacktrace<Allocator>& st);
os << to_string(st);
os
.template<class charT, class traits> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const stacktrace_entry& f);
os << to_string(f)
.os
.template<> struct hash<stacktrace_entry>; template<class Allocator> struct hash<basic_stacktrace<Allocator>>;
[Note for editor: Add a macro [version.syn] - end note]
#define __cpp_lib_stacktrace DATE_OF_ADOPTION // also in <stacktrace>
Many thanks to Jens Maurer, JF Bastien, Marshall Clow and Tim Song for pointing out many issues in the early wordings.
Special thanks to Jens Maurer for doing the core wordings.
Many many thanks to all the people who participated in the LWG meeting on 20th of August and reviewed early version of the wording.