Get macOS JIT compiled frames working

Still need support for object files.

Author: jeaye

src/binary/mach-o.cpp

@@ -42,6 +42,48 @@ namespace detail {
             std::string name;
         };
 
+        struct object_relocation {
+            std::uint32_t address;
+            std::uint32_t symbolnum;
+            std::uint8_t pcrel;
+            std::uint8_t length;
+            std::uint8_t external;
+            std::uint8_t type;
+        };
+
+        struct object_symbol {
+            std::uint8_t type;
+            std::uint8_t sect;
+            std::uint16_t desc;
+            uint64_t value;
+            std::string name;
+        };
+
+        struct object_section {
+            std::string name;
+            std::string segment_name;
+            std::uint32_t flags;
+            uint64_t addr;
+            std::uint32_t offset;
+            uint64_t size;
+            std::uint32_t align;
+            std::uint32_t reloff;
+            std::uint32_t nreloc;
+            std::vector<char> data;
+            std::vector<object_relocation> relocations;
+        };
+
+        struct object_data {
+            bool is_little_endian;
+            bool is_64_bit;
+            std::uint32_t filetype;
+            cpu_type_t cpu_type;
+            cpu_subtype_t cpu_subtype;
+            std::size_t size;
+            std::vector<object_section> sections;
+            std::vector<object_symbol> symbols;
+        };
+
         // map from object file to a vector of symbols to resolve
         using debug_map = std::unordered_map<std::string, std::vector<debug_map_entry>>;
 
@@ -114,6 +156,7 @@ namespace detail {
         Result<debug_map, internal_error> get_debug_map();
 
         Result<const std::vector<symbol_entry>&, internal_error> symbol_table();
+        Result<object_data, internal_error> get_object_data();
 
         optional<std::string> lookup_symbol(frame_ptr pc);
 
@@ -128,6 +171,8 @@ namespace detail {
 
         template<std::size_t Bits>
         Result<segment_command_64, internal_error> load_segment_command(std::uint32_t offset) const;
+        template<std::size_t Bits>
+        Result<section_64, internal_error> load_section(std::uint32_t offset) const;
 
         Result<symtab_command, internal_error> load_symbol_table_command(std::uint32_t offset) const;
 

src/binary/mach-o.hpp

@@ -2,6 +2,7 @@
 
 #include "cpptrace/forward.hpp"
 #include "utils/error.hpp"
+#include "logging.hpp"
 #include "utils/optional.hpp"
 #include "utils/span.hpp"
 #include "binary/elf.hpp"
@@ -11,6 +12,7 @@
 #endif
 
 #include <algorithm>
+#include <cstdint>
 #include <iostream>
 #include <fstream>
 #include <map>
@@ -46,8 +48,10 @@ namespace detail {
 
     public:
         void add_jit_object(cbspan object) {
+            log::debug("jit add_jit_object start: ptr={} size={}", reinterpret_cast<std::uintptr_t>(object.data()), object.size());
             auto object_res = jit_object_type::open(object);
             if(object_res.is_error()) {
+                log::warn("jit add_jit_object: failed to parse object ptr={} size={}", reinterpret_cast<std::uintptr_t>(object.data()), object.size());
                 if(!should_absorb_trace_exceptions()) {
                     object_res.drop_error();
                 }
@@ -61,11 +65,17 @@ namespace detail {
                 #endif
             };
             #ifdef CPPTRACE_GET_SYMBOLS_WITH_LIBDWARF
-            #if IS_LINUX
+            #if IS_LINUX || IS_APPLE
             auto dwarf_object_res = entry.object->get_object_data();
             if(dwarf_object_res) {
                 entry.dwarf_resolver = libdwarf::make_dwarf_resolver(std::move(dwarf_object_res).unwrap_value());
+                log::debug(
+                    "jit add_jit_object: created in-memory dwarf resolver ptr={} resolver={}",
+                    reinterpret_cast<std::uintptr_t>(object.data()),
+                    reinterpret_cast<std::uintptr_t>(entry.dwarf_resolver.get())
+                );
             } else if(!should_absorb_trace_exceptions()) {
+                log::warn("jit add_jit_object: failed to build in-memory dwarf object ptr={}", reinterpret_cast<std::uintptr_t>(object.data()));
                 dwarf_object_res.drop_error();
             }
             #endif
@@ -74,13 +84,16 @@ namespace detail {
             auto* object_file = objects.back().object.get();
             auto ranges_res = object_file->get_pc_ranges();
             if(ranges_res.is_error()) {
+                log::warn("jit add_jit_object: failed to extract pc ranges ptr={}", reinterpret_cast<std::uintptr_t>(object.data()));
                 if(!should_absorb_trace_exceptions()) {
                     ranges_res.drop_error();
                 }
                 return;
             }
             auto& ranges = ranges_res.unwrap_value();
+            log::debug("jit add_jit_object: ptr={} extracted {} pc ranges", reinterpret_cast<std::uintptr_t>(object.data()), ranges.size());
             for(auto range : ranges) {
+                log::debug("jit add_jit_object: range [{}, {})", range.low, range.high);
                 range_entry entry{
                     range.low,
                     range.high,
@@ -116,6 +129,7 @@ namespace detail {
         }
 
         optional<jit_object_lookup_result> lookup(frame_ptr pc) const {
+            log::debug("jit lookup: pc={} range_count={}", pc, range_list.size());
             auto it = first_less_than_or_equal(
                 range_list.begin(),
                 range_list.end(),
@@ -125,10 +139,23 @@ namespace detail {
                 }
             );
             if(it == range_list.end()) {
+                log::debug("jit lookup: miss, no candidate range for pc={}", pc);
                 return nullopt;
             }
             ASSERT(pc >= it->low);
             if(pc < it->high) {
+                log::debug(
+                    "jit lookup: hit pc={} in [{}, {}) object_ptr={} dwarf_resolver={}",
+                    pc,
+                    it->low,
+                    it->high,
+                    reinterpret_cast<std::uintptr_t>(it->object_start),
+                    #ifdef CPPTRACE_GET_SYMBOLS_WITH_LIBDWARF
+                    reinterpret_cast<std::uintptr_t>(it->dwarf_resolver)
+                    #else
+                    0
+                    #endif
+                );
                 return jit_object_lookup_result{
                     *it->object,
                     it->low
@@ -137,6 +164,7 @@ namespace detail {
                     #endif
                 };
             } else {
+                log::debug("jit lookup: miss, candidate range [{}, {}) does not contain pc={}", it->low, it->high, pc);
                 return nullopt;
             }
         }