| 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 |