Merge branch 'dev'

Author: jeremy-rifkin

.github/workflows/ci.yml

@@ -707,6 +707,34 @@ jobs:
            ninja
            ./unittest
 
+  unittest-linux-gcc-4-8-5:
+    runs-on: ubuntu-24.04
+    needs: unittest-linux
+    steps:
+    - uses: actions/checkout@v4
+    - name: dependencies
+      run: |
+           wget http://mirrors.kernel.org/ubuntu/pool/universe/g/gcc-4.8/g++-4.8_4.8.5-4ubuntu8_amd64.deb
+           wget http://mirrors.kernel.org/ubuntu/pool/universe/g/gcc-4.8/libstdc++-4.8-dev_4.8.5-4ubuntu8_amd64.deb
+           wget http://mirrors.kernel.org/ubuntu/pool/universe/g/gcc-4.8/gcc-4.8-base_4.8.5-4ubuntu8_amd64.deb
+           wget http://mirrors.kernel.org/ubuntu/pool/universe/g/gcc-4.8/gcc-4.8_4.8.5-4ubuntu8_amd64.deb
+           wget http://mirrors.kernel.org/ubuntu/pool/universe/g/gcc-4.8/libgcc-4.8-dev_4.8.5-4ubuntu8_amd64.deb
+           wget http://mirrors.kernel.org/ubuntu/pool/universe/g/gcc-4.8/cpp-4.8_4.8.5-4ubuntu8_amd64.deb
+           wget http://mirrors.kernel.org/ubuntu/pool/universe/g/gcc-4.8/libasan0_4.8.5-4ubuntu8_amd64.deb
+           sudo apt install ./gcc-4.8_4.8.5-4ubuntu8_amd64.deb ./gcc-4.8-base_4.8.5-4ubuntu8_amd64.deb ./libstdc++-4.8-dev_4.8.5-4ubuntu8_amd64.deb ./cpp-4.8_4.8.5-4ubuntu8_amd64.deb ./libgcc-4.8-dev_4.8.5-4ubuntu8_amd64.deb ./libasan0_4.8.5-4ubuntu8_amd64.deb ./g++-4.8_4.8.5-4ubuntu8_amd64.deb
+    - name: build and test
+      run: |
+           mkdir build
+           cd build
+           cmake .. \
+             -GNinja \
+             -DCMAKE_BUILD_TYPE=Debug \
+             -DCMAKE_CXX_COMPILER=g++-4.8 \
+             -DCMAKE_C_COMPILER=gcc-4.8 \
+             -DCPPTRACE_WERROR_BUILD=On \
+             -DCPPTRACE_STD_FORMAT=Off
+           ninja
+
   unittest-windows-32-bit:
     runs-on: windows-2022
     needs: unittest-windows
@@ -736,6 +764,7 @@ jobs:
       fail-fast: false
       matrix:
         build_type: [Debug]
+        arch: [x64, Win32]
     steps:
     - uses: actions/checkout@v4
     - name: Enable Developer Command Prompt
@@ -746,6 +775,7 @@ jobs:
            cd build
            cmake .. `
             -T ClangCL `
+            -A ${{matrix.arch}} `
             -DCPPTRACE_WERROR_BUILD=On `
             -DCPPTRACE_BUILD_TESTING=On
            cmake --build . --config ${{matrix.build_type}}

README.md

@@ -1513,6 +1513,10 @@ target_link_libraries(main PRIVATE cpptrace::cpptrace)
 Cpptrace supports C++20 modules: `import cpptrace;`. You'll need a modern toolchain in order to use C++20 modules (i.e.
 relatively new compilers, cmake, etc).
 
+For features involving macros you will have to `#include` headers with the macro definitions:
+- `<cpptrace/exceptions_macros.hpp>`: `CPPTRACE_WRAP` and `CPPTRACE_WRAP_BLOCK`
+- `<cpptrace/from_current_macros.hpp>`: `CPPTRACE_TRY`, `CPPTRACE_CATCH`, etc.
+
 # Platform Logistics
 
 Windows and macOS require a little extra work to get everything in the right place.

include/cpptrace/formatting.hpp

@@ -56,9 +56,12 @@ CPPTRACE_BEGIN_NAMESPACE
         formatter& filtered_frame_placeholders(bool);
         formatter& filter(std::function<bool(const stacktrace_frame&)>);
         formatter& transform(std::function<stacktrace_frame(stacktrace_frame)>);
+        formatter& break_before_filename(bool do_break = true);
 
         std::string format(const stacktrace_frame&) const;
         std::string format(const stacktrace_frame&, bool color) const;
+        // The last argument is the indent to use for the filename, if break_before_filename is set
+        std::string format(const stacktrace_frame&, bool color, size_t filename_indent) const;
 
         std::string format(const stacktrace&) const;
         std::string format(const stacktrace&, bool color) const;
@@ -67,8 +70,12 @@ CPPTRACE_BEGIN_NAMESPACE
         void print(const stacktrace_frame&, bool color) const;
         void print(std::ostream&, const stacktrace_frame&) const;
         void print(std::ostream&, const stacktrace_frame&, bool color) const;
+        // The last argument is the indent to use for the filename, if break_before_filename is set
+        void print(std::ostream&, const stacktrace_frame&, bool color, size_t filename_indent) const;
         void print(std::FILE*, const stacktrace_frame&) const;
         void print(std::FILE*, const stacktrace_frame&, bool color) const;
+        // The last argument is the indent to use for the filename, if break_before_filename is set
+        void print(std::FILE*, const stacktrace_frame&, bool color, size_t filename_indent) const;
 
         void print(const stacktrace&) const;
         void print(const stacktrace&, bool color) const;

src/formatting.cpp

@@ -64,6 +64,7 @@ CPPTRACE_BEGIN_NAMESPACE
             address_mode addresses = address_mode::raw;
             path_mode paths = path_mode::full;
             bool snippets = false;
+            bool break_before_filename = false;
             int context_lines = 2;
             bool columns = true;
             symbol_mode symbols = symbol_mode::full;
@@ -106,13 +107,17 @@ CPPTRACE_BEGIN_NAMESPACE
         void transform(std::function<stacktrace_frame(stacktrace_frame)> transform) {
             options.transform = std::move(transform);
         }
+        void break_before_filename(bool do_break) {
+            options.break_before_filename = do_break;
+        }
 
         std::string format(
             const stacktrace_frame& frame,
-            detail::optional<bool> color_override = detail::nullopt
+            detail::optional<bool> color_override = detail::nullopt,
+            size_t filename_indent = 0
         ) const {
             std::ostringstream oss;
-            print_internal(oss, frame, color_override.value_or(options.color == color_mode::always));
+            print_internal(oss, frame, color_override.value_or(options.color == color_mode::always), filename_indent);
             return std::move(oss).str();
         }
 
@@ -128,17 +133,19 @@ CPPTRACE_BEGIN_NAMESPACE
         void print(
             std::ostream& stream,
             const stacktrace_frame& frame,
-            detail::optional<bool> color_override = detail::nullopt
+            detail::optional<bool> color_override = detail::nullopt,
+            size_t filename_indent = 0
         ) const {
-            print_internal(stream, frame, color_override);
+            print_internal(stream, frame, color_override, filename_indent);
             stream << "\n";
         }
         void print(
             std::FILE* file,
             const stacktrace_frame& frame,
-            detail::optional<bool> color_override = detail::nullopt
+            detail::optional<bool> color_override = detail::nullopt,
+            size_t filename_indent = 0
         ) const {
-            auto str = format(frame, color_override);
+            auto str = format(frame, color_override, filename_indent);
             str += "\n";
             std::fwrite(str.data(), 1, str.size(), file);
         }
@@ -206,15 +213,15 @@ CPPTRACE_BEGIN_NAMESPACE
             return do_color;
         }
 
-        void print_internal(std::ostream& stream, const stacktrace_frame& input_frame, detail::optional<bool> color_override) const {
+        void print_internal(std::ostream& stream, const stacktrace_frame& input_frame, detail::optional<bool> color_override, size_t col_indent) const {
             bool color = should_do_color(stream, color_override);
             maybe_ensure_virtual_terminal_processing(stream, color);
             detail::optional<stacktrace_frame> transformed_frame;
             if(options.transform) {
                 transformed_frame = options.transform(input_frame);
             }
             const stacktrace_frame& frame = options.transform ? transformed_frame.unwrap() : input_frame;
-            write_frame(stream, frame, color);
+            write_frame(stream, frame, color, col_indent);
         }
 
         void print_internal(std::ostream& stream, const stacktrace& trace, detail::optional<bool> color_override) const {
@@ -223,6 +230,7 @@ CPPTRACE_BEGIN_NAMESPACE
             write_trace(stream, trace, color);
         }
 
+
         void write_trace(std::ostream& stream, const stacktrace& trace, bool color) const {
             if(!options.header.empty()) {
                 stream << options.header << '\n';
@@ -245,11 +253,12 @@ CPPTRACE_BEGIN_NAMESPACE
                     counter++;
                     continue;
                 }
-                microfmt::print(stream, "#{<{}} ", frame_number_width, counter);
+
+                size_t filename_indent = write_frame_number(stream, frame_number_width, counter);
                 if(filter_out_frame) {
                     microfmt::print(stream, "(filtered)");
                 } else {
-                    write_frame(stream, frame, color);
+                    write_frame(stream, frame, color, filename_indent);
                     if(frame.line.has_value() && !frame.filename.empty() && options.snippets) {
                         auto snippet = detail::get_snippet(
                             frame.filename,
@@ -270,29 +279,45 @@ CPPTRACE_BEGIN_NAMESPACE
             }
         }
 
-        void write_frame(std::ostream& stream, const stacktrace_frame& frame, color_setting color) const {
-            write_address(stream, frame, color);
+        /// Write the frame number, and return the number of characters written
+        size_t write_frame_number(std::ostream& stream, unsigned int frame_number_width, size_t counter) const
+        {
+            microfmt::print(stream, "#{<{}} ", frame_number_width, counter);
+            return 2 + frame_number_width;
+        }
+
+        void write_frame(std::ostream& stream, const stacktrace_frame& frame, color_setting color, size_t col) const {
+            col += write_address(stream, frame, color);
             if(frame.is_inline || options.addresses != address_mode::none) {
                 stream << ' ';
+                col += 1;
             }
             if(!frame.symbol.empty()) {
                 write_symbol(stream, frame, color);
             }
             if(!frame.symbol.empty() && !frame.filename.empty()) {
-                stream << ' ';
+                if(options.break_before_filename) {
+                    microfmt::print(stream, "\n{<{}}", col, "");
+                } else {
+                    stream << ' ';
+                }
             }
             if(!frame.filename.empty()) {
                 write_source_location(stream, frame, color);
             }
         }
 
-        void write_address(std::ostream& stream, const stacktrace_frame& frame, color_setting color) const {
+        /// Write the address of the frame, return the number of characters written
+        size_t write_address(std::ostream& stream, const stacktrace_frame& frame, color_setting color) const {
             if(frame.is_inline) {
                 microfmt::print(stream, "{<{}}", 2 * sizeof(frame_ptr) + 2, "(inlined)");
+                return 2 * sizeof(frame_ptr) + 2;
             } else if(options.addresses != address_mode::none) {
                 auto address = options.addresses == address_mode::raw ? frame.raw_address : frame.object_address;
                 microfmt::print(stream, "{}0x{>{}:0h}{}", color.blue(), 2 * sizeof(frame_ptr), address, color.reset());
+                return 2 * sizeof(frame_ptr) + 2;
             }
+            return 0;
         }
 
         void write_symbol(std::ostream& stream, const stacktrace_frame& frame, color_setting color) const {
@@ -399,13 +424,20 @@ CPPTRACE_BEGIN_NAMESPACE
         pimpl->transform(std::move(transform));
         return *this;
     }
+    formatter& formatter::break_before_filename(bool do_break) {
+        pimpl->break_before_filename(do_break);
+        return *this;
+    }
 
     std::string formatter::format(const stacktrace_frame& frame) const {
         return pimpl->format(frame);
     }
     std::string formatter::format(const stacktrace_frame& frame, bool color) const {
         return pimpl->format(frame, color);
     }
+    std::string formatter::format(const stacktrace_frame& frame, bool color, size_t filename_indent) const {
+        return pimpl->format(frame, color, filename_indent);
+    }
 
     std::string formatter::format(const stacktrace& trace) const {
         return pimpl->format(trace);
@@ -445,12 +477,18 @@ CPPTRACE_BEGIN_NAMESPACE
     void formatter::print(std::ostream& stream, const stacktrace_frame& frame, bool color) const {
         pimpl->print(stream, frame, color);
     }
+    void formatter::print(std::ostream& stream, const stacktrace_frame& frame, bool color, size_t filename_indent) const {
+        pimpl->print(stream, frame, color, filename_indent);
+    }
     void formatter::print(std::FILE* file, const stacktrace_frame& frame) const {
         pimpl->print(file, frame);
     }
     void formatter::print(std::FILE* file, const stacktrace_frame& frame, bool color) const {
         pimpl->print(file, frame, color);
     }
+    void formatter::print(std::FILE* file, const stacktrace_frame& frame, bool color, size_t filename_indent) const {
+        pimpl->print(file, frame, color, filename_indent);
+    }
 
     const formatter& get_default_formatter() {
         static formatter formatter;

src/from_current.cpp

@@ -92,42 +92,37 @@ namespace detail {
     // - https://github.com/ecatmur/stacktrace-from-exception/blob/main/stacktrace-from-exception.cpp
     // - https://github.com/catboost/catboost/blob/master/contrib/libs/cxxsupp/libcxx/src/support/runtime/exception_pointer_msvc.ipp
     // - https://www.geoffchappell.com/studies/msvc/language/predefined/index.htm
-    #ifdef _WIN64
-     #pragma pack(push, 4)
-     struct CatchableType {
-         std::uint32_t properties;
-         std::int32_t pType;
-         std::uint32_t non_virtual_adjustment; // these next three are from _PMD
-         std::uint32_t offset_to_virtual_base_ptr;
-         std::uint32_t virtual_base_table_index;
-         std::uint32_t sizeOrOffset;
-         std::int32_t copyFunction;
-     };
-     struct ThrowInfo {
-         std::uint32_t attributes;
-         std::int32_t pmfnUnwind;
-         std::int32_t pForwardCompat;
-         std::int32_t pCatchableTypeArray;
-     };
-     #pragma warning(disable:4200)
-     #if IS_CLANG
-      #pragma clang diagnostic push
-      #pragma clang diagnostic ignored "-Wc99-extensions"
-     #endif
-     struct CatchableTypeArray {
-         uint32_t nCatchableTypes;
-         int32_t arrayOfCatchableTypes[];
-     };
-     #if IS_CLANG
-      #pragma clang diagnostic pop
-     #endif
-     #pragma warning (pop)
-     #pragma pack(pop)
-    #else
-     using CatchableTypeArray = ::_CatchableTypeArray;
-     using CatchableType = ::_CatchableType;
-     using ThrowInfo = ::_ThrowInfo;
+    #pragma pack(push, 4)
+    struct CatchableType {
+        std::uint32_t properties;
+        std::int32_t pType;
+        std::uint32_t non_virtual_adjustment; // these next three are from _PMD
+        std::uint32_t offset_to_virtual_base_ptr;
+        std::uint32_t virtual_base_table_index;
+        std::uint32_t sizeOrOffset;
+        std::int32_t copyFunction;
+    };
+    struct ThrowInfo {
+        std::uint32_t attributes;
+        std::int32_t pmfnUnwind;
+        std::int32_t pForwardCompat;
+        std::int32_t pCatchableTypeArray;
+    };
+    #pragma warning(push)
+    #pragma warning(disable:4200)
+    #if IS_CLANG
+     #pragma clang diagnostic push
+     #pragma clang diagnostic ignored "-Wc99-extensions"
     #endif
+    struct CatchableTypeArray {
+        uint32_t nCatchableTypes;
+        int32_t arrayOfCatchableTypes[];
+    };
+    #if IS_CLANG
+     #pragma clang diagnostic pop
+    #endif
+    #pragma warning(pop)
+    #pragma pack(pop)
 
     static constexpr unsigned EH_MAGIC_NUMBER1 = 0x19930520; // '?msc' version magic, see ehdata.h
     static constexpr unsigned EH_EXCEPTION_NUMBER = 0xE06D7363;  // '?msc', 'msc' | 0xE0000000
@@ -174,6 +169,7 @@ namespace detail {
             #ifdef _WIN64
              return reinterpret_cast<T>((uintptr_t)module_pointer + (uintptr_t)address);
             #else
+             (void)module_pointer;
              return reinterpret_cast<T>(address);
             #endif
         }
@@ -575,7 +571,12 @@ namespace detail {
         void** type_info_vtable_pointer = *static_cast<void***>(type_info_pointer);
         // the type info vtable pointer points to two pointers inside the vtable, adjust it back
         type_info_vtable_pointer -= 2;
-        auto* can_catch_fn = reinterpret_cast<decltype(can_catch)*>(type_info_vtable_pointer[6]);
+        auto* can_catch_fn =
+            #if IS_GCC
+             // error: ISO C++ forbids casting between pointer-to-function and pointer-to-object on old gcc
+             __extension__
+            #endif
+            reinterpret_cast<decltype(can_catch)*>(type_info_vtable_pointer[6]);
         return can_catch_fn(type, throw_type, throw_obj, outer);
     }
     #endif

src/unwind/unwind_with_dbghelp.cpp

@@ -86,7 +86,7 @@ namespace detail {
         frame.AddrFrame.Mode   = AddrModeFlat;
         frame.AddrStack.Offset = context.Rsp;
         frame.AddrStack.Mode   = AddrModeFlat;
-        #elif defined(_M_IA64) || defined(__aarch64__)
+        #elif defined(_M_IA64)
         machine_type           = IMAGE_FILE_MACHINE_IA64;
         frame.AddrPC.Offset    = context.StIIP;
         frame.AddrPC.Mode      = AddrModeFlat;
@@ -96,6 +96,14 @@ namespace detail {
         frame.AddrBStore.Mode  = AddrModeFlat;
         frame.AddrStack.Offset = context.IntSp;
         frame.AddrStack.Mode   = AddrModeFlat;
+        #elif defined(_M_ARM64) || defined(__aarch64__)
+        machine_type           = IMAGE_FILE_MACHINE_ARM64;
+        frame.AddrPC.Offset    = context.Pc;
+        frame.AddrPC.Mode      = AddrModeFlat;
+        frame.AddrFrame.Offset = context.Fp;
+        frame.AddrFrame.Mode   = AddrModeFlat;
+        frame.AddrStack.Offset = context.Sp;
+        frame.AddrStack.Mode   = AddrModeFlat;
         #else
         #error "Cpptrace: StackWalk64 not supported for this platform yet"
         #endif