Merge branch 'dev' into jr/abi

Author: jeremy-rifkin

src/utils/io/base_file.hpp

@@ -14,7 +14,13 @@ namespace internal {
         virtual string_view path() const = 0;
         virtual Result<monostate, internal_error> read_bytes(bspan buffer, off_t offset) const = 0;
 
-        template<typename T, typename std::enable_if<std::is_trivial<T>::value && !is_span<T>::value, int>::type = 0>
+        template<
+            typename T,
+            typename std::enable_if<
+                std::is_standard_layout<T>::value && std::is_trivially_copyable<T>::value && !is_span<T>::value,
+                int
+            >::type = 0
+        >
         Result<T, internal_error> read(off_t offset) {
             T object{};
             auto res = read_bytes(make_bspan(object), offset);
@@ -24,7 +30,13 @@ namespace internal {
             return object;
         }
 
-        template<typename T, typename std::enable_if<std::is_trivial<T>::value, int>::type = 0>
+        template<
+            typename T,
+            typename std::enable_if<
+                std::is_standard_layout<T>::value && std::is_trivially_copyable<T>::value,
+                int
+            >::type = 0
+        >
         Result<monostate, internal_error> read_span(span<T> items, off_t offset) {
             return read_bytes(
                 make_span(reinterpret_cast<char*>(items.data()), reinterpret_cast<char*>(items.data() + items.size())),

src/utils/span.hpp

@@ -82,7 +82,13 @@ namespace internal {
         return {begin, count};
     }
 
-    template<typename T, typename std::enable_if<std::is_trivial<T>::value && !is_span<T>::value, int>::type = 0>
+    template<
+        typename T,
+        typename std::enable_if<
+            std::is_standard_layout<T>::value && std::is_trivially_copyable<T>::value && !is_span<T>::value,
+            int
+        >::type = 0
+    >
     span<char> make_bspan(T& object) {
         return span<char>(reinterpret_cast<char*>(std::addressof(object)), sizeof(object));
     }

src/utils/utils.hpp

@@ -147,7 +147,13 @@ namespace internal {
     }
 
     // TODO: Re-evaluate use of off_t
-    template<typename T, typename std::enable_if<std::is_trivial<T>::value, int>::type = 0>
+    template<
+        typename T,
+        typename std::enable_if<
+            std::is_standard_layout<T>::value && std::is_trivially_copyable<T>::value,
+            int
+        >::type = 0
+    >
     Result<T, internal_error> load_bytes(std::FILE* object_file, off_t offset) {
         T object;
         if(std::fseek(object_file, offset, SEEK_SET) != 0) {
@@ -210,7 +216,7 @@ namespace internal {
         //  <= 19.23 msvc also appears to fail (but for a different reason https://godbolt.org/z/6Y5EvdWPK)
         //  <= 19.39 msvc also has trouble with it for different reasons https://godbolt.org/z/aPPPT7z3z
         typename std::enable_if<
-            std::is_standard_layout<T>::value && std::is_trivial<T>::value,
+            std::is_standard_layout<T>::value && std::is_trivially_copyable<T>::value,
             int
         >::type = 0,
         typename std::enable_if<

test/CMakeLists.txt

@@ -35,10 +35,12 @@ endmacro()
 add_executable(integration integration.cpp)
 add_executable(demo demo.cpp)
 add_executable(c_demo ctrace_demo.c)
+add_executable(link_test link_test.cpp)
 
 add_test_dependencies(integration)
 add_test_dependencies(demo)
 add_test_dependencies(c_demo)
+add_test_dependencies(link_test)
 
 if(UNIX)
   add_executable(signal_demo signal_demo.cpp)

test/link_test.cpp

@@ -0,0 +1,82 @@
+#include "cpptrace/basic.hpp"
+#include "cpptrace/utils.hpp"
+#include <cpptrace/cpptrace.hpp>
+
+#include <iostream>
+
+// These are just here to make sure all symbols are found
+
+int main() {
+    auto r = cpptrace::raw_trace::current();
+    r = cpptrace::raw_trace::current(0, 100);
+    r.resolve();
+    r.clear();
+    r.empty();
+
+    auto o = cpptrace::object_trace::current();
+    o = cpptrace::object_trace::current(0, 100);
+    o.resolve();
+    o.clear();
+    o.empty();
+
+    auto s = cpptrace::stacktrace::current();
+    s = cpptrace::stacktrace::current(0, 100);
+    s.print();
+    s.print(std::cerr);
+    s.print(std::cerr, true);
+    s.print_with_snippets();
+    s.print_with_snippets(std::cerr);
+    s.print_with_snippets(std::cerr, true);
+    s.to_string();
+    std::cerr<<s<<std::endl;
+    auto f = s.frames[0];
+    f.get_object_info();
+    f.to_string();
+    f.to_string(true);
+    std::cerr<<f<<std::endl;
+    s.clear();
+    s.empty();
+
+    cpptrace::generate_raw_trace();
+    cpptrace::generate_raw_trace(0, 100);
+    cpptrace::generate_object_trace();
+    cpptrace::generate_object_trace(0, 100);
+    cpptrace::generate_trace();
+    cpptrace::generate_trace(0, 100);
+
+    cpptrace::safe_generate_raw_trace(nullptr, 0, 0);
+    cpptrace::safe_generate_raw_trace(nullptr, 0, 0, 0);
+
+    cpptrace::safe_object_frame sf;
+    cpptrace::get_safe_object_frame(0, &sf);
+    cpptrace::can_signal_safe_unwind();
+    cpptrace::can_get_safe_object_frame();
+
+    cpptrace::register_jit_object(nullptr, 0);
+    cpptrace::unregister_jit_object(nullptr);
+    cpptrace::clear_all_jit_objects();
+
+    cpptrace::lazy_exception l;
+    l.what();
+    l.message();
+    l.trace();
+
+    cpptrace::demangle("test");
+    cpptrace::get_snippet(__FILE__, 1, 1);
+    cpptrace::isatty(cpptrace::stderr_fileno);
+
+    cpptrace::register_terminate_handler();
+
+    cpptrace::absorb_trace_exceptions(true);
+
+    cpptrace::enable_inlined_call_resolution(true);
+
+    cpptrace::set_log_level(cpptrace::log_level::debug);
+    cpptrace::set_log_callback([](cpptrace::log_level, const char*) {});
+    cpptrace::use_default_stderr_logger();
+
+    cpptrace::experimental::set_cache_mode(cpptrace::cache_mode::hybrid);
+
+    cpptrace::experimental::set_dwarf_resolver_line_table_cache_size(100);
+    cpptrace::experimental::set_dwarf_resolver_disable_aranges(true);
+}