microsoft · StephanTLavavej · Jun 12, 2022 · Jan 23, 2022 · Jan 23, 2022 · Jan 23, 2022
@@ -185,6 +185,7 @@ set(HEADERS
     ${CMAKE_CURRENT_LIST_DIR}/inc/spanstream
     ${CMAKE_CURRENT_LIST_DIR}/inc/sstream
     ${CMAKE_CURRENT_LIST_DIR}/inc/stack
+    ${CMAKE_CURRENT_LIST_DIR}/inc/stacktrace
     ${CMAKE_CURRENT_LIST_DIR}/inc/stdatomic.h
     ${CMAKE_CURRENT_LIST_DIR}/inc/stdexcept
     ${CMAKE_CURRENT_LIST_DIR}/inc/stop_token
@@ -256,6 +257,7 @@ set(IMPLIB_SOURCES
     ${CMAKE_CURRENT_LIST_DIR}/src/locale0_implib.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/nothrow.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/sharedmutex.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/src/stacktrace.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/syserror_import_lib.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/vector_algorithms.cpp
     ${CMAKE_CURRENT_LIST_DIR}/src/xonce2.cpp
@@ -456,7 +458,7 @@ function(add_stl_dlls D_SUFFIX THIS_CONFIG_DEFINITIONS THIS_CONFIG_COMPILE_OPTIO
     target_compile_options(msvcp${D_SUFFIX}_eha_objects PRIVATE "${THIS_CONFIG_COMPILE_OPTIONS};${GL_FLAG};/EHa")
 
     add_library(msvcp${D_SUFFIX} SHARED)
-    target_link_libraries(msvcp${D_SUFFIX} PRIVATE msvcp${D_SUFFIX}_eha_objects msvcp${D_SUFFIX}_objects msvcp${D_SUFFIX}_init_objects "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib")
+    target_link_libraries(msvcp${D_SUFFIX} PRIVATE msvcp${D_SUFFIX}_eha_objects msvcp${D_SUFFIX}_objects msvcp${D_SUFFIX}_init_objects "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib" "DbgEng.lib")
     set_target_properties(msvcp${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_base${D_SUFFIX}${VCLIBS_SUFFIX}")
     set_target_properties(msvcp${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
     set_target_properties(msvcp${D_SUFFIX} PROPERTIES OUTPUT_NAME "msvcp140${D_SUFFIX}${VCLIBS_SUFFIX}")
@@ -477,7 +479,7 @@ function(add_stl_dlls D_SUFFIX THIS_CONFIG_DEFINITIONS THIS_CONFIG_COMPILE_OPTIO
     target_compile_options(msvcp_1${D_SUFFIX}_objects PRIVATE "${THIS_CONFIG_COMPILE_OPTIONS};${GL_FLAG};/EHsc")
 
     add_library(msvcp_1${D_SUFFIX} SHARED)
-    target_link_libraries(msvcp_1${D_SUFFIX} PRIVATE msvcp_1${D_SUFFIX}_objects msvcp${D_SUFFIX}_satellite_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib")
+    target_link_libraries(msvcp_1${D_SUFFIX} PRIVATE msvcp_1${D_SUFFIX}_objects msvcp${D_SUFFIX}_satellite_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib" "DbgEng.lib")
     set_target_properties(msvcp_1${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_1${D_SUFFIX}${VCLIBS_SUFFIX}")
     set_target_properties(msvcp_1${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
     set_target_properties(msvcp_1${D_SUFFIX} PROPERTIES OUTPUT_NAME "msvcp140_1${D_SUFFIX}${VCLIBS_SUFFIX}")
@@ -490,7 +492,7 @@ function(add_stl_dlls D_SUFFIX THIS_CONFIG_DEFINITIONS THIS_CONFIG_COMPILE_OPTIO
     target_link_libraries(msvcp_2${D_SUFFIX}_objects PRIVATE Boost::math)
 
     add_library(msvcp_2${D_SUFFIX} SHARED)
-    target_link_libraries(msvcp_2${D_SUFFIX} PRIVATE msvcp_2${D_SUFFIX}_objects msvcp${D_SUFFIX}_satellite_objects msvcp${D_SUFFIX}_implib_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib")
+    target_link_libraries(msvcp_2${D_SUFFIX} PRIVATE msvcp_2${D_SUFFIX}_objects msvcp${D_SUFFIX}_satellite_objects msvcp${D_SUFFIX}_implib_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib" "DbgEng.lib")
     set_target_properties(msvcp_2${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_2${D_SUFFIX}${VCLIBS_SUFFIX}")
     set_target_properties(msvcp_2${D_SUFFIX} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
     set_target_properties(msvcp_2${D_SUFFIX} PROPERTIES OUTPUT_NAME "msvcp140_2${D_SUFFIX}${VCLIBS_SUFFIX}")
@@ -512,7 +514,7 @@ function(add_stl_dlls D_SUFFIX THIS_CONFIG_DEFINITIONS THIS_CONFIG_COMPILE_OPTIO
     file(WRITE "${_ATOMIC_WAIT_DEF_NAME}" "${_ATOMIC_WAIT_DEF_CONTENTS}")
 
     add_library(msvcp${D_SUFFIX}_atomic_wait SHARED "${_ATOMIC_WAIT_DEF_NAME}")
-    target_link_libraries(msvcp${D_SUFFIX}_atomic_wait PRIVATE msvcp${D_SUFFIX}_atomic_wait_objects msvcp${D_SUFFIX}_satellite_objects msvcp${D_SUFFIX}_implib_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib" "advapi32.lib")
+    target_link_libraries(msvcp${D_SUFFIX}_atomic_wait PRIVATE msvcp${D_SUFFIX}_atomic_wait_objects msvcp${D_SUFFIX}_satellite_objects msvcp${D_SUFFIX}_implib_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib" "advapi32.lib" "DbgEng.lib")
     set_target_properties(msvcp${D_SUFFIX}_atomic_wait PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_atomic_wait${D_SUFFIX}${VCLIBS_SUFFIX}")
     set_target_properties(msvcp${D_SUFFIX}_atomic_wait PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
     set_target_properties(msvcp${D_SUFFIX}_atomic_wait PROPERTIES OUTPUT_NAME "${_ATOMIC_WAIT_OUTPUT_NAME}")
@@ -524,7 +526,7 @@ function(add_stl_dlls D_SUFFIX THIS_CONFIG_DEFINITIONS THIS_CONFIG_COMPILE_OPTIO
     target_compile_options(msvcp${D_SUFFIX}_codecvt_ids_objects PRIVATE "${THIS_CONFIG_COMPILE_OPTIONS};${GL_FLAG};/EHsc")
 
     add_library(msvcp${D_SUFFIX}_codecvt_ids SHARED)
-    target_link_libraries(msvcp${D_SUFFIX}_codecvt_ids PRIVATE msvcp${D_SUFFIX}_codecvt_ids_objects msvcp${D_SUFFIX}_satellite_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib")
+    target_link_libraries(msvcp${D_SUFFIX}_codecvt_ids PRIVATE msvcp${D_SUFFIX}_codecvt_ids_objects msvcp${D_SUFFIX}_satellite_objects "msvcp${D_SUFFIX}" "${TOOLSET_LIB}/vcruntime${D_SUFFIX}.lib" "${TOOLSET_LIB}/msvcrt${D_SUFFIX}.lib" "ucrt${D_SUFFIX}.lib" "DbgEng.lib")
     set_target_properties(msvcp${D_SUFFIX}_codecvt_ids PROPERTIES ARCHIVE_OUTPUT_NAME "msvcp140_codecvt_ids${D_SUFFIX}${VCLIBS_SUFFIX}")
     set_target_properties(msvcp${D_SUFFIX}_codecvt_ids PROPERTIES ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
     set_target_properties(msvcp${D_SUFFIX}_codecvt_ids PROPERTIES OUTPUT_NAME "msvcp140${D_SUFFIX}_codecvt_ids${VCLIBS_SUFFIX}")

@@ -120,6 +120,7 @@
 #include <spanstream>
 #include <sstream>
 #include <stack>
+#include <stacktrace>
 #include <stdexcept>
 #include <streambuf>
 #include <string>

@@ -95,6 +95,7 @@
         "spanstream",
         "sstream",
         "stack",
+        "stacktrace",
         "stdatomic.h",
         "stdexcept",
         "stop_token",

@@ -0,0 +1,316 @@
+// stacktrace standard header
+
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+#ifndef _STACKSTRACE_
+#define _STACKSTRACE_
+#include <yvals_core.h>
+#if _STL_COMPILER_PREPROCESSOR
+
+#if !_HAS_CXX23
+#pragma message("The contents of <stacktrace> are available only with C++23 or later.")
+#else // ^^^ !_HAS_CXX23 / _HAS_CXX23 vvv
+
+#include <cstdint>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#pragma pack(push, _CRT_PACKING)
+#pragma warning(push, _STL_WARNING_LEVEL)
+#pragma warning(disable : _STL_DISABLED_WARNINGS)
+_STL_DISABLE_CLANG_WARNINGS
+#pragma push_macro("new")
+#undef new
+
+using _Stacktrace_string_fill_callback = size_t (*)(char*, size_t, void* _Context);
+
+using _Stacktrace_string_fill = size_t (*)(size_t, void* _String, void* _Context, _Stacktrace_string_fill_callback);
+
+struct _Stacktrace_string_fill_op {
+    size_t operator()(char* _Data, size_t _Size) {
+        return _Callback(_Data, _Size, _Context);
+    }
+
+    _Stacktrace_string_fill_callback _Callback;
+    void* _Context;
+};
+
+inline size_t _Stacktrace_string_fill_impl(
+    size_t _Size, void* _String, void* _Context, _Stacktrace_string_fill_callback _Callback) {
+    static_cast<_STD string*>(_String)->resize_and_overwrite(_Size, _Stacktrace_string_fill_op{_Callback, _Context});
+    return static_cast<_STD string*>(_String)->size();
+}
+
+_EXTERN_C
+unsigned short __stdcall __std_stacktrace_capture(
+    unsigned long _FramesToSkip, unsigned long _FramesToCapture, void** _BackTrace, unsigned long* _BackTraceHash);
+
+void __stdcall __std_stacktrace_address_to_string(const void* _Address, void* _Str, _Stacktrace_string_fill _Fill);
+void __stdcall __std_stacktrace_description(const void* _Address, void* _Str, _Stacktrace_string_fill _Fill);
+void __stdcall __std_stacktrace_source_file(const void* _Address, void* _Str, _Stacktrace_string_fill _Fill);
+[[nodiscard]] unsigned __stdcall __std_stacktrace_source_line(const void* _Address);
+void __stdcall __std_stacktrace_to_string(
+    const void* _Addresses, size_t _Size, void* _Str, _Stacktrace_string_fill _Fill);
+_END_EXTERN_C
+
+_STD_BEGIN
+class stacktrace_entry {
+public:
+    using native_handle_type = void*;
+
+    constexpr stacktrace_entry() noexcept                        = default;
+    constexpr stacktrace_entry(const stacktrace_entry&) noexcept = default;
+    constexpr stacktrace_entry& operator=(const stacktrace_entry&) noexcept = default;
+
+    ~stacktrace_entry() = default;
+
+    [[nodiscard]] constexpr native_handle_type native_handle() const noexcept {
+        return _Address;
+    }
+
+    [[nodiscard]] constexpr explicit operator bool() const noexcept {
+        return _Address != nullptr;
+    }
+
+    [[nodiscard]] string description() const {
+        string _Result;
+        __std_stacktrace_description(_Address, &_Result, _Stacktrace_string_fill_impl);
+        return _Result;
+    }
+
+    [[nodiscard]] string source_file() const {
+        string _Result;
+        __std_stacktrace_source_file(_Address, &_Result, _Stacktrace_string_fill_impl);
+        return _Result;
+    }
+
+    [[nodiscard]] uint_least32_t source_line() const {
+        return __std_stacktrace_source_line(_Address);
+    }
+
+    [[nodiscard]] friend constexpr bool operator==(const stacktrace_entry&, const stacktrace_entry&) noexcept = default;
+
+    [[nodiscard]] friend constexpr strong_ordering operator<=>(
+        const stacktrace_entry&, const stacktrace_entry&) noexcept = default;
+
+private:
+    void* _Address = nullptr;
+};
+
+template <class _Al>
+class basic_stacktrace {
+private:
+    using _Frames_t = vector<stacktrace_entry, _Al>;
+
+public:
+    using value_type             = stacktrace_entry;
+    using const_reference        = const value_type&;
+    using reference              = value_type&;
+    using const_iterator         = typename _Frames_t::const_iterator;
+    using iterator               = const_iterator;
+    using reverse_iterator       = _STD reverse_iterator<iterator>;
+    using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
+    using difference_type        = ptrdiff_t;
+    using size_type              = size_t;
+    using allocator_type         = _Al;
+
+    [[nodiscard]] static basic_stacktrace current(const allocator_type& _Alloc = allocator_type()) noexcept {
+        basic_stacktrace _Result(_Internal_t{}, _Max_frames, _Alloc);
+        _Result._Frames.resize(__std_stacktrace_capture(0, static_cast<unsigned long>(_Max_frames),
+            reinterpret_cast<void**>(_Result._Frames.data()), &_Result._Hash));
+        return _Result;
+    }
+
+    [[nodiscard]] static basic_stacktrace current(
+        size_type _Skip, const allocator_type& _Alloc = allocator_type()) noexcept {
+        basic_stacktrace _Result(_Internal_t{}, _Max_frames, _Alloc);
+        _Result._Frames.resize(__std_stacktrace_capture(static_cast<unsigned long>(_Skip),
+            static_cast<unsigned long>(_Max_frames), reinterpret_cast<void**>(_Result._Frames.data()), &_Result._Hash));
+        return _Result;
+    }
+
+    [[nodiscard]] static basic_stacktrace current(
+        size_type _Skip, size_type _Max_depth, const allocator_type& _Alloc = allocator_type()) noexcept {
+        basic_stacktrace _Result(_Internal_t{}, _Max_depth, _Alloc);
+        _Result._Frames.resize(__std_stacktrace_capture(static_cast<unsigned long>(_Skip),
+            static_cast<unsigned long>(_Max_depth), reinterpret_cast<void**>(_Result._Frames.data()), &_Result._Hash));
+        return _Result;
+    }
+
+    basic_stacktrace() noexcept(is_nothrow_default_constructible_v<allocator_type>) = default;
+    explicit basic_stacktrace(const allocator_type& _Alloc) noexcept : _Frames(_Alloc) {}
+
+    basic_stacktrace(const basic_stacktrace&)     = default;
+    basic_stacktrace(basic_stacktrace&&) noexcept = default;
+    basic_stacktrace(const basic_stacktrace& _Other, const allocator_type& _Alloc)
+        : _Frames(_Other._Frames, _Alloc), _Hash(_Other._Hash) {}
+
+    basic_stacktrace(basic_stacktrace&& _Other, const allocator_type& _Alloc)
+        : _Frames(_STD move(_Other._Frames), _Alloc), _Hash(_Other._Hash) {}
+
+    basic_stacktrace& operator=(const basic_stacktrace&) = default;
+    basic_stacktrace& operator=(basic_stacktrace&&) noexcept(_Noex_move) = default;
+
+    ~basic_stacktrace() = default;
+
+    [[nodiscard]] allocator_type get_allocator() const noexcept {
+        return _Frames.get_allocator();
+    }
+
+    [[nodiscard]] const_iterator begin() const noexcept {
+        return _Frames.cbegin();
+    }
+
+    [[nodiscard]] const_iterator end() const noexcept {
+        return _Frames.cend();
+    }
+
+    [[nodiscard]] const_reverse_iterator rbegin() const noexcept {
+        return _Frames.crbegin();
+    }
+
+    [[nodiscard]] const_reverse_iterator rend() const noexcept {
+        return _Frames.crend();
+    }
+
+    [[nodiscard]] const_iterator cbegin() const noexcept {
+        return _Frames.cbegin();
+    }
+
+    [[nodiscard]] const_iterator cend() const noexcept {
+        return _Frames.cend();
+    }
+
+    [[nodiscard]] const_reverse_iterator crbegin() const noexcept {
+        return _Frames.crbegin();
+    }
+
+    [[nodiscard]] const_reverse_iterator crend() const noexcept {
+        return _Frames.crend();
+    }
+
+    [[nodiscard]] bool empty() const noexcept {
+        return _Frames.empty();
+    }
+
+    [[nodiscard]] size_type size() const noexcept {
+        return _Frames.size();
+    }
+
+    [[nodiscard]] size_type max_size() const noexcept {
+        return _Frames.max_size();
+    }
+
+    [[nodiscard]] const_reference operator[](size_type _Sx) const noexcept /* strengthened */ {
+        return _Frames[_Sx];
+    }
+
+    [[nodiscard]] const_reference at(size_type _Sx) const {
+        return _Frames.at(_Sx);
+    }
+
+    template <class _Al2>
+    [[nodiscard]] friend bool operator==(const basic_stacktrace& _Lhs, const basic_stacktrace<_Al2>& _Rhs) noexcept {
+        return _Lhs._Hash == _Rhs._Hash && _Lhs._Frames == _Rhs._Frames;
+    }
+
+    template <class _Al2>
+    [[nodiscard]] friend strong_ordering operator<=>(
+        const basic_stacktrace& _Lhs, const basic_stacktrace<_Al2>& _Rhs) noexcept {
+        const auto _Result = _Lhs._Frames.size() <=> _Rhs._Frames.size();
+        if (_Result != strong_ordering::equal) {
+            return _Result;
+        }
+
+        return _Lhs._Frames <=> _Rhs._Frames;
+    }
+
+    void swap(basic_stacktrace& _Other) noexcept(
+        allocator_traits<_Al>::propagate_on_container_swap::value || allocator_traits<_Al>::is_always_equal::value) {
+        _STD swap(_Frames, _Other._Frames);
+        _STD swap(_Hash, _Other._Hash);
+    }
+
+    [[nodiscard]] unsigned long _Get_hash() const noexcept {
+        return _Hash;
+    }
+
+    [[nodiscard]] const void* _Data() const noexcept {
+        return _Frames.data();
+    }
+
+
+private:
+    static constexpr size_t _Max_frames = 0xFFFF;
+
+    static constexpr bool _Noex_move = allocator_traits<_Al>::propagate_on_container_move_assignment::value
+                                    || allocator_traits<_Al>::is_always_equal::value;
+
+    struct _Internal_t {};
+
+    basic_stacktrace(_Internal_t, size_type _Max_depth, const allocator_type& _Alloc) : _Frames(_Max_depth, _Alloc) {}
+
+    _Frames_t _Frames;
+    unsigned long _Hash = 0;
+};
+
+using stacktrace = basic_stacktrace<allocator<stacktrace_entry>>;
+
+template <class _Al>
+void swap(basic_stacktrace<_Al>& _Ax, basic_stacktrace<_Al>& _Bx) noexcept(noexcept(_Ax.swap(_Bx))) {
+    return _Ax.swap(_Bx);
+}
+
+[[nodiscard]] inline string to_string(const stacktrace_entry& _Fx) {
+    string _Result;
+    __std_stacktrace_address_to_string(_Fx.native_handle(), &_Result, _Stacktrace_string_fill_impl);
+    return _Result;
+}
+
+template <class _Al>
+[[nodiscard]] string to_string(const basic_stacktrace<_Al>& _St) {
+    string _Result;
+    __std_stacktrace_to_string(_St._Data(), _St.size(), &_Result, _Stacktrace_string_fill_impl);
+    return _Result;
+}
+
+template <class charT, class traits>
+basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& _Os, const stacktrace_entry& _Fx) {
+    return _Os << to_string(_Fx);
+}
+
+template <class charT, class traits, class _Al>
+basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& _Os, const basic_stacktrace<_Al>& _Fx) {
+    return _Os << to_string(_Fx);
+}
+
+namespace pmr {
+    using stacktrace = basic_stacktrace<polymorphic_allocator<stacktrace_entry>>;
+}
+
+template <>
+struct hash<stacktrace_entry> {
+    [[nodiscard]] size_t operator()(const stacktrace_entry& _Val) const noexcept {
+        return _Hash_representation(_Val.native_handle());
+    }
+};
+
+template <class _Al>
+struct hash<basic_stacktrace<_Al>> {
+    [[nodiscard]] size_t operator()(const basic_stacktrace<_Al>& _Val) const noexcept {
+        return _Val._Get_hash();
+    }
+};
+_STD_END
+
+#pragma pop_macro("new")
+_STL_RESTORE_CLANG_WARNINGS
+#pragma warning(pop)
+#pragma pack(pop)
+#endif // ^^^ _HAS_CXX23 ^^^
+
+#endif // _STL_COMPILER_PREPROCESSOR
+#endif // _STACK_