Debian Codegraph @

src/jit/jit_objects.cpp

raw
1 #include "jit/jit_objects.hpp"
2
3 #include "cpptrace/forward.hpp"
4 #include "utils/error.hpp"
5 #include "utils/optional.hpp"
6 #include "utils/span.hpp"
7 #include "binary/elf.hpp"
8 #include "binary/mach-o.hpp"
9
10 #include <algorithm>
11 #include <iostream>
12 #include <fstream>
13 #include <map>
14 #include <vector>
15
16 CPPTRACE_BEGIN_NAMESPACE
17 namespace detail {
18 #if IS_LINUX || IS_APPLE
19 class jit_object_manager {
20 struct object_entry {
21 const char* object_start;
22 std::unique_ptr<jit_object_type> object;
23 };
24 std::vector<object_entry> objects;
25
26 struct range_entry {
27 frame_ptr low;
28 frame_ptr high; // not inclusive
29 const char* object_start;
30 jit_object_type* object;
31 bool operator<(const range_entry& other) const {
32 return low < other.low;
33 }
34 };
35 // TODO: Maybe use a set...
36 std::vector<range_entry> range_list;
37
38 public:
39 void add_jit_object(cbspan object) {
40 auto object_res = jit_object_type::open(object);
41 if(object_res.is_error()) {
42 if(!should_absorb_trace_exceptions()) {
43 object_res.drop_error();
44 }
45 return;
46 }
47 objects.push_back({object.data(), make_unique<jit_object_type>(std::move(object_res).unwrap_value())});
48 auto* object_file = objects.back().object.get();
49 auto ranges_res = object_file->get_pc_ranges();
50 if(ranges_res.is_error()) {
51 if(!should_absorb_trace_exceptions()) {
52 ranges_res.drop_error();
53 }
54 return;
55 }
56 auto& ranges = ranges_res.unwrap_value();
57 for(auto range : ranges) {
58 range_entry entry{range.low, range.high, object.data(), object_file};
59 // TODO: Perf
60 range_list.insert(std::upper_bound(range_list.begin(), range_list.end(), entry), entry);
61 }
62 }
63
64 void remove_jit_object(const char* ptr) {
65 // TODO: Perf
66 objects.erase(
67 std::remove_if(
68 objects.begin(),
69 objects.end(),
70 [&](const object_entry& entry) { return entry.object_start == ptr; }
71 ),
72 objects.end()
73 );
74 range_list.erase(
75 std::remove_if(
76 range_list.begin(),
77 range_list.end(),
78 [&](const range_entry& entry) { return entry.object_start == ptr; }
79 ),
80 range_list.end()
81 );
82 }
83
84 optional<jit_object_lookup_result> lookup(frame_ptr pc) const {
85 auto it = first_less_than_or_equal(
86 range_list.begin(),
87 range_list.end(),
88 pc,
89 [](frame_ptr pc, const range_entry& entry) {
90 return pc < entry.low;
91 }
92 );
93 if(it == range_list.end()) {
94 return nullopt;
95 }
96 ASSERT(pc >= it->low);
97 if(pc < it->high) {
98 return jit_object_lookup_result{*it->object, it->low};
99 } else {
100 return nullopt;
101 }
102 }
103
104 void clear_all_jit_objects() {
105 objects.clear();
106 range_list.clear();
107 }
108 };
109 #else
110 class jit_object_manager {
111 public:
112 void add_jit_object(cbspan) {}
113 void remove_jit_object(const char*) {}
114 void clear_all_jit_objects() {}
115 };
116 #endif
117
118 jit_object_manager& get_jit_object_manager() {
119 static jit_object_manager manager;
120 return manager;
121 }
122
123 void register_jit_object(const char* ptr, std::size_t size) {
124 auto& manager = get_jit_object_manager();
125 manager.add_jit_object(make_span(ptr, size));
126 }
127
128 void unregister_jit_object(const char* ptr) {
129 auto& manager = get_jit_object_manager();
130 manager.remove_jit_object(ptr);
131 }
132
133 void clear_all_jit_objects() {
134 auto& manager = get_jit_object_manager();
135 manager.clear_all_jit_objects();
136 }
137
138 #if IS_LINUX || IS_APPLE
139 optional<jit_object_lookup_result> lookup_jit_object(frame_ptr pc) {
140 return get_jit_object_manager().lookup(pc);
141 }
142 #endif
143 }
144 CPPTRACE_END_NAMESPACE