Debian Codegraph @

libdrgn/register_state.c

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include <limits.h>
5
6 #include "debug_info.h"
7 #include "register_state.h"
8
9 #define drgn_register_state_known_bitset(regs) ({ \
10 __auto_type _state = (regs); \
11 &_state->buf[_state->regs_size]; \
12 })
13
14 static inline uint32_t drgn_register_state_bitset_size(uint16_t num_regs)
15 {
16 return ((uint32_t)num_regs + CHAR_BIT + 1) / CHAR_BIT;
17 }
18
19 struct drgn_register_state *drgn_register_state_create_impl(uint32_t regs_size,
20 uint16_t num_regs,
21 bool interrupted)
22 {
23 uint32_t bitset_size = drgn_register_state_bitset_size(num_regs);
24 size_t size;
25 struct drgn_register_state *regs;
26 if (__builtin_add_overflow(regs_size, bitset_size, &size) ||
27 __builtin_add_overflow(size, sizeof(*regs), &size) ||
28 !(regs = malloc(size)))
29 return NULL;
30 regs->module = NULL;
31 regs->regs_size = regs_size;
32 regs->num_regs = num_regs;
33 regs->interrupted = interrupted;
34 memset(drgn_register_state_known_bitset(regs), 0, bitset_size);
35 return regs;
36 }
37
38 struct drgn_register_state *
39 drgn_register_state_dup(const struct drgn_register_state *regs)
40 {
41 size_t size;
42 struct drgn_register_state *ret;
43 if (__builtin_add_overflow(regs->regs_size,
44 drgn_register_state_bitset_size(regs->num_regs),
45 &size) ||
46 __builtin_add_overflow(size, sizeof(*ret), &size) ||
47 !(ret = malloc(size)))
48 return NULL;
49 memcpy(ret, regs, size);
50 return ret;
51 }
52
53 static bool
54 drgn_register_state_is_known(const struct drgn_register_state *regs, uint32_t i)
55 {
56 const unsigned char *bitset = drgn_register_state_known_bitset(regs);
57 return (bitset[i / CHAR_BIT] & (1 << (i % CHAR_BIT))) != 0;
58 }
59
60 static void drgn_register_state_set_known(struct drgn_register_state *regs,
61 uint32_t i)
62 {
63 unsigned char *bitset = drgn_register_state_known_bitset(regs);
64 bitset[i / CHAR_BIT] |= 1 << (i % CHAR_BIT);
65 }
66
67 static void drgn_register_state_set_unknown(struct drgn_register_state *regs,
68 uint32_t i)
69 {
70 unsigned char *bitset = drgn_register_state_known_bitset(regs);
71 bitset[i / CHAR_BIT] &= ~(1 << (i % CHAR_BIT));
72 }
73
74 bool drgn_register_state_has_register(const struct drgn_register_state *regs,
75 drgn_register_number regno)
76 {
77 return (regno < regs->num_regs &&
78 drgn_register_state_is_known(regs, (uint32_t)regno + 2));
79 }
80
81 void drgn_register_state_set_has_register(struct drgn_register_state *regs,
82 drgn_register_number regno)
83 {
84 assert(regno < regs->num_regs);
85 drgn_register_state_set_known(regs, (uint32_t)regno + 2);
86 }
87
88 void
89 drgn_register_state_set_has_register_range(struct drgn_register_state *regs,
90 drgn_register_number first_regno,
91 drgn_register_number last_regno)
92 {
93 assert(first_regno <= last_regno);
94 assert(last_regno < regs->num_regs);
95 for (uint32_t regno = first_regno; regno <= last_regno; regno++)
96 drgn_register_state_set_known(regs, regno + 2);
97 }
98
99 void drgn_register_state_unset_has_register(struct drgn_register_state *regs,
100 drgn_register_number regno)
101 {
102 if (regno < regs->num_regs)
103 drgn_register_state_set_unknown(regs, (uint32_t)regno + 2);
104 }
105
106 struct optional_uint64
107 drgn_register_state_get_pc(const struct drgn_register_state *regs)
108 {
109 return (struct optional_uint64){
110 regs->_pc,
111 drgn_register_state_is_known(regs, 0),
112 };
113 }
114
115 void drgn_register_state_set_pc(struct drgn_program *prog,
116 struct drgn_register_state *regs, uint64_t pc)
117 {
118 pc &= drgn_platform_address_mask(&prog->platform);
119 regs->_pc = pc;
120 drgn_register_state_set_known(regs, 0);
121 regs->module = drgn_module_find_by_address(prog,
122 pc - !regs->interrupted);
123 }
124
125 struct optional_uint64
126 drgn_register_state_get_cfa(const struct drgn_register_state *regs)
127 {
128 return (struct optional_uint64){
129 regs->_cfa,
130 drgn_register_state_is_known(regs, 1),
131 };
132 }
133
134 void drgn_register_state_set_cfa(struct drgn_program *prog,
135 struct drgn_register_state *regs, uint64_t cfa)
136 {
137 regs->_cfa = cfa & drgn_platform_address_mask(&prog->platform);
138 drgn_register_state_set_known(regs, 1);
139 }
140
141 struct optional_uint64
142 drgn_register_state_get_u64_impl(struct drgn_program *prog,
143 struct drgn_register_state *regs,
144 drgn_register_number regno,
145 size_t reg_offset, size_t reg_size)
146 {
147 struct optional_uint64 ret = {
148 .has_value = drgn_register_state_has_register(regs, regno),
149 };
150 if (ret.has_value) {
151 copy_lsbytes(&ret.value, sizeof(ret.value), HOST_LITTLE_ENDIAN,
152 &regs->buf[reg_offset], reg_size,
153 drgn_platform_is_little_endian(&prog->platform));
154 }
155 return ret;
156 }