drgn/libdrgn/platform.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

234 lines
5.8 KiB
C
Raw Normal View History

// Copyright (c) Meta Platforms, Inc. and affiliates.
// SPDX-License-Identifier: GPL-3.0-or-later
#include <byteswap.h>
#include <elf.h>
#include <stdlib.h>
#include "platform.h"
#include "util.h"
const struct drgn_register *drgn_register_by_name_unknown(const char *name)
{
return NULL;
}
const struct drgn_architecture_info arch_info_unknown = {
.name = "unknown",
.arch = DRGN_ARCH_UNKNOWN,
.register_by_name = drgn_register_by_name_unknown,
};
LIBDRGN_PUBLIC const struct drgn_platform drgn_host_platform = {
#if __x86_64__
.arch = &arch_info_x86_64,
#elif __i386__
.arch = &arch_info_i386,
#elif __aarch64__
.arch = &arch_info_aarch64,
#elif __arm__
.arch = &arch_info_arm,
#elif __powerpc64__
.arch = &arch_info_ppc64,
#elif __riscv
#if __riscv_xlen == 64
.arch = &arch_info_riscv64,
#elif __riscv_xlen == 32
.arch = &arch_info_riscv32,
#else
#error "unknown __riscv_xlen"
#endif
#else
.arch = &arch_info_unknown,
#endif
.flags = ((sizeof(void *) == 8 ? DRGN_PLATFORM_IS_64_BIT : 0) |
(HOST_LITTLE_ENDIAN ? DRGN_PLATFORM_IS_LITTLE_ENDIAN : 0)),
};
LIBDRGN_PUBLIC struct drgn_error *
drgn_platform_create(enum drgn_architecture arch,
enum drgn_platform_flags flags, struct drgn_platform **ret)
{
const struct drgn_architecture_info *arch_info;
struct drgn_platform *platform;
SWITCH_ENUM_DEFAULT(arch,
case DRGN_ARCH_UNKNOWN:
arch_info = &arch_info_unknown;
break;
case DRGN_ARCH_X86_64:
arch_info = &arch_info_x86_64;
break;
case DRGN_ARCH_I386:
arch_info = &arch_info_i386;
break;
case DRGN_ARCH_AARCH64:
arch_info = &arch_info_aarch64;
break;
case DRGN_ARCH_ARM:
arch_info = &arch_info_arm;
break;
case DRGN_ARCH_PPC64:
arch_info = &arch_info_ppc64;
break;
case DRGN_ARCH_RISCV64:
arch_info = &arch_info_riscv64;
break;
case DRGN_ARCH_RISCV32:
arch_info = &arch_info_riscv32;
break;
default:
return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
"invalid architecture");
)
if (flags == DRGN_PLATFORM_DEFAULT_FLAGS) {
if (arch == DRGN_ARCH_UNKNOWN) {
return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
"cannot get default platform flags of unknown architecture");
}
flags = arch_info->default_flags;
} else if (flags & ~DRGN_ALL_PLATFORM_FLAGS) {
return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
"invalid platform flags");
}
platform = malloc(sizeof(*platform));
if (!platform)
return &drgn_enomem;
platform->arch = arch_info;
platform->flags = flags;
*ret = platform;
return NULL;
}
LIBDRGN_PUBLIC void drgn_platform_destroy(struct drgn_platform *platform)
{
free(platform);
}
LIBDRGN_PUBLIC enum drgn_architecture
drgn_platform_arch(const struct drgn_platform *platform)
{
return platform->arch->arch;
}
LIBDRGN_PUBLIC enum drgn_platform_flags
drgn_platform_flags(const struct drgn_platform *platform)
{
return platform->flags;
}
LIBDRGN_PUBLIC bool drgn_platform_eq(struct drgn_platform *a,
struct drgn_platform *b)
{
return a->arch == b->arch && a->flags == b->flags;
}
void drgn_platform_from_arch(const struct drgn_architecture_info *arch,
bool is_64_bit, bool is_little_endian,
struct drgn_platform *ret)
{
ret->arch = arch;
ret->flags = (arch->default_flags &
~(DRGN_PLATFORM_IS_64_BIT | DRGN_PLATFORM_IS_LITTLE_ENDIAN));
if (is_64_bit)
ret->flags |= DRGN_PLATFORM_IS_64_BIT;
if (is_little_endian)
ret->flags |= DRGN_PLATFORM_IS_LITTLE_ENDIAN;
}
void drgn_platform_from_elf(GElf_Ehdr *ehdr, struct drgn_platform *ret)
{
const struct drgn_architecture_info *arch;
switch (ehdr->e_machine) {
case EM_X86_64:
arch = &arch_info_x86_64;
break;
case EM_386:
arch = &arch_info_i386;
break;
case EM_AARCH64:
arch = &arch_info_aarch64;
break;
case EM_ARM:
arch = &arch_info_arm;
break;
case EM_PPC64:
arch = &arch_info_ppc64;
break;
case EM_RISCV:
if (ehdr->e_ident[EI_CLASS] == ELFCLASS64)
arch = &arch_info_riscv64;
else
arch = &arch_info_riscv32;
break;
default:
arch = &arch_info_unknown;
break;
}
drgn_platform_from_arch(arch, ehdr->e_ident[EI_CLASS] == ELFCLASS64,
ehdr->e_ident[EI_DATA] == ELFDATA2LSB, ret);
}
LIBDRGN_PUBLIC size_t
drgn_platform_num_registers(const struct drgn_platform *platform)
{
return platform->arch->num_registers;
}
LIBDRGN_PUBLIC const struct drgn_register *
drgn_platform_register(const struct drgn_platform *platform, size_t n)
{
return &platform->arch->registers[n];
}
LIBDRGN_PUBLIC const struct drgn_register *
drgn_platform_register_by_name(const struct drgn_platform *platform,
const char *name)
{
return platform->arch->register_by_name(name);
}
LIBDRGN_PUBLIC const char * const *
drgn_register_names(const struct drgn_register *reg, size_t *num_names_ret)
{
*num_names_ret = reg->num_names;
return reg->names;
}
struct drgn_error drgn_invalid_relocation_offset = {
.code = DRGN_ERROR_OTHER,
.message = "invalid relocation offset",
};
#define DEFINE_DRGN_RELOC_ADD(bits) \
struct drgn_error * \
drgn_reloc_add##bits(const struct drgn_relocating_section *relocating, \
uint64_t r_offset, const int64_t *r_addend, \
uint##bits##_t addend) \
{ \
uint##bits##_t value; \
if (r_offset > relocating->buf_size || \
relocating->buf_size - r_offset < sizeof(value)) \
return &drgn_invalid_relocation_offset; \
if (r_addend) { \
value = *r_addend; \
} else { \
memcpy(&value, relocating->buf + r_offset, sizeof(value)); \
if (relocating->bswap) \
value = bswap_##bits(value); \
} \
value += addend; \
if (relocating->bswap) \
value = bswap_##bits(value); \
memcpy(relocating->buf + r_offset, &value, sizeof(value)); \
return NULL; \
}
DEFINE_DRGN_RELOC_ADD(64)
DEFINE_DRGN_RELOC_ADD(32)
DEFINE_DRGN_RELOC_ADD(16)
#define bswap_8(x) (x)
DEFINE_DRGN_RELOC_ADD(8)
#undef bswap_8
#undef DEFINE_DRGN_RELOC_ADD