Debian Codegraph @

libdrgn/platform.c

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include <byteswap.h>
5 #include <elf.h>
6 #include <stdlib.h>
7 #include <string.h>
8
9 #include "platform.h"
10
11 const struct drgn_register *drgn_register_by_name_unknown(const char *name)
12 {
13 return NULL;
14 }
15
16 const struct drgn_architecture_info arch_info_unknown = {
17 .name = "unknown",
18 .arch = DRGN_ARCH_UNKNOWN,
19 .register_by_name = drgn_register_by_name_unknown,
20 };
21
22 LIBDRGN_PUBLIC const struct drgn_platform drgn_host_platform = {
23 #if __x86_64__
24 .arch = &arch_info_x86_64,
25 #elif __i386__
26 .arch = &arch_info_i386,
27 #elif __aarch64__
28 .arch = &arch_info_aarch64,
29 #elif __arm__
30 .arch = &arch_info_arm,
31 #elif __powerpc64__
32 .arch = &arch_info_ppc64,
33 #elif __riscv
34 #if __riscv_xlen == 64
35 .arch = &arch_info_riscv64,
36 #elif __riscv_xlen == 32
37 .arch = &arch_info_riscv32,
38 #else
39 #error "unknown __riscv_xlen"
40 #endif
41 #elif __s390x__
42 .arch = &arch_info_s390x,
43 // __s390__ is also defined for s390x, so the order is important.
44 #elif __s390__
45 .arch = &arch_info_s390,
46 #else
47 .arch = &arch_info_unknown,
48 #endif
49 .flags = ((sizeof(void *) == 8 ? DRGN_PLATFORM_IS_64_BIT : 0) |
50 (HOST_LITTLE_ENDIAN ? DRGN_PLATFORM_IS_LITTLE_ENDIAN : 0)),
51 };
52
53 LIBDRGN_PUBLIC struct drgn_error *
54 drgn_platform_create(enum drgn_architecture arch,
55 enum drgn_platform_flags flags, struct drgn_platform **ret)
56 {
57 const struct drgn_architecture_info *arch_info;
58 struct drgn_platform *platform;
59
60 SWITCH_ENUM(arch) {
61 case DRGN_ARCH_UNKNOWN:
62 arch_info = &arch_info_unknown;
63 break;
64 case DRGN_ARCH_X86_64:
65 arch_info = &arch_info_x86_64;
66 break;
67 case DRGN_ARCH_I386:
68 arch_info = &arch_info_i386;
69 break;
70 case DRGN_ARCH_AARCH64:
71 arch_info = &arch_info_aarch64;
72 break;
73 case DRGN_ARCH_ARM:
74 arch_info = &arch_info_arm;
75 break;
76 case DRGN_ARCH_PPC64:
77 arch_info = &arch_info_ppc64;
78 break;
79 case DRGN_ARCH_RISCV64:
80 arch_info = &arch_info_riscv64;
81 break;
82 case DRGN_ARCH_RISCV32:
83 arch_info = &arch_info_riscv32;
84 break;
85 case DRGN_ARCH_S390X:
86 arch_info = &arch_info_s390x;
87 break;
88 case DRGN_ARCH_S390:
89 arch_info = &arch_info_s390;
90 break;
91 default:
92 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
93 "invalid architecture");
94 }
95 if (flags == DRGN_PLATFORM_DEFAULT_FLAGS) {
96 if (arch == DRGN_ARCH_UNKNOWN) {
97 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
98 "cannot get default platform flags of unknown architecture");
99 }
100 flags = arch_info->default_flags;
101 } else if (flags & ~DRGN_ALL_PLATFORM_FLAGS) {
102 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
103 "invalid platform flags");
104 }
105 platform = malloc(sizeof(*platform));
106 if (!platform)
107 return &drgn_enomem;
108 platform->arch = arch_info;
109 platform->flags = flags;
110 *ret = platform;
111 return NULL;
112 }
113
114 LIBDRGN_PUBLIC void drgn_platform_destroy(struct drgn_platform *platform)
115 {
116 free(platform);
117 }
118
119 LIBDRGN_PUBLIC enum drgn_architecture
120 drgn_platform_arch(const struct drgn_platform *platform)
121 {
122 return platform->arch->arch;
123 }
124
125 LIBDRGN_PUBLIC enum drgn_platform_flags
126 drgn_platform_flags(const struct drgn_platform *platform)
127 {
128 return platform->flags;
129 }
130
131 LIBDRGN_PUBLIC bool drgn_platform_eq(struct drgn_platform *a,
132 struct drgn_platform *b)
133 {
134 return a->arch == b->arch && a->flags == b->flags;
135 }
136
137 void drgn_platform_from_arch(const struct drgn_architecture_info *arch,
138 bool is_64_bit, bool is_little_endian,
139 struct drgn_platform *ret)
140 {
141 ret->arch = arch;
142 ret->flags = (arch->default_flags &
143 ~(DRGN_PLATFORM_IS_64_BIT | DRGN_PLATFORM_IS_LITTLE_ENDIAN));
144 if (is_64_bit)
145 ret->flags |= DRGN_PLATFORM_IS_64_BIT;
146 if (is_little_endian)
147 ret->flags |= DRGN_PLATFORM_IS_LITTLE_ENDIAN;
148 }
149
150 void drgn_platform_from_elf(GElf_Ehdr *ehdr, struct drgn_platform *ret)
151 {
152 const struct drgn_architecture_info *arch;
153
154 switch (ehdr->e_machine) {
155 case EM_X86_64:
156 arch = &arch_info_x86_64;
157 break;
158 case EM_386:
159 arch = &arch_info_i386;
160 break;
161 case EM_AARCH64:
162 arch = &arch_info_aarch64;
163 break;
164 case EM_ARM:
165 arch = &arch_info_arm;
166 break;
167 case EM_PPC64:
168 arch = &arch_info_ppc64;
169 break;
170 case EM_RISCV:
171 if (ehdr->e_ident[EI_CLASS] == ELFCLASS64)
172 arch = &arch_info_riscv64;
173 else
174 arch = &arch_info_riscv32;
175 break;
176 case EM_S390:
177 if (ehdr->e_ident[EI_CLASS] == ELFCLASS64)
178 arch = &arch_info_s390x;
179 else
180 arch = &arch_info_s390;
181 break;
182 default:
183 arch = &arch_info_unknown;
184 break;
185 }
186 drgn_platform_from_arch(arch, ehdr->e_ident[EI_CLASS] == ELFCLASS64,
187 ehdr->e_ident[EI_DATA] == ELFDATA2LSB, ret);
188 }
189
190 LIBDRGN_PUBLIC size_t
191 drgn_platform_num_registers(const struct drgn_platform *platform)
192 {
193 return platform->arch->num_registers;
194 }
195
196 LIBDRGN_PUBLIC const struct drgn_register *
197 drgn_platform_register(const struct drgn_platform *platform, size_t n)
198 {
199 return &platform->arch->registers[n];
200 }
201
202 LIBDRGN_PUBLIC const struct drgn_register *
203 drgn_platform_register_by_name(const struct drgn_platform *platform,
204 const char *name)
205 {
206 return platform->arch->register_by_name(name);
207 }
208
209 LIBDRGN_PUBLIC const char * const *
210 drgn_register_names(const struct drgn_register *reg, size_t *num_names_ret)
211 {
212 *num_names_ret = reg->num_names;
213 return reg->names;
214 }
215
216 struct drgn_error drgn_invalid_relocation_offset = {
217 .code = DRGN_ERROR_OTHER,
218 .message = "invalid relocation offset",
219 };
220
221 #define DEFINE_DRGN_RELOC_ADD(bits) \
222 struct drgn_error * \
223 drgn_reloc_add##bits(const struct drgn_relocating_section *relocating, \
224 uint64_t r_offset, const int64_t *r_addend, \
225 uint##bits##_t addend) \
226 { \
227 uint##bits##_t value; \
228 if (r_offset > relocating->buf_size || \
229 relocating->buf_size - r_offset < sizeof(value)) \
230 return &drgn_invalid_relocation_offset; \
231 if (r_addend) { \
232 value = *r_addend; \
233 } else { \
234 memcpy(&value, relocating->buf + r_offset, sizeof(value)); \
235 if (relocating->bswap) \
236 value = bswap_##bits(value); \
237 } \
238 value += addend; \
239 if (relocating->bswap) \
240 value = bswap_##bits(value); \
241 memcpy(relocating->buf + r_offset, &value, sizeof(value)); \
242 return NULL; \
243 }
244 DEFINE_DRGN_RELOC_ADD(64)
245 DEFINE_DRGN_RELOC_ADD(32)
246 DEFINE_DRGN_RELOC_ADD(16)
247 #define bswap_8(x) (x)
248 DEFINE_DRGN_RELOC_ADD(8)
249 #undef bswap_8
250 #undef DEFINE_DRGN_RELOC_ADD