path: root/tools/objtool/arch/x86/decode.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (C) 2015 Josh Poimboeuf <jpoimboe@redhat.com>
 */

#include <stdio.h>
#include <stdlib.h>

#define unlikely(cond) (cond)
#include <asm/insn.h>
#include "../../../arch/x86/lib/inat.c"
#include "../../../arch/x86/lib/insn.c"

#define CONFIG_64BIT 1
#include <asm/nops.h>

#include <asm/orc_types.h>
#include <objtool/check.h>
#include <objtool/disas.h>
#include <objtool/elf.h>
#include <objtool/arch.h>
#include <objtool/warn.h>
#include <objtool/builtin.h>
#include <arch/elf.h>

const char *arch_reg_name[CFI_NUM_REGS] = {
	"rax", "rcx", "rdx", "rbx",
	"rsp", "rbp", "rsi", "rdi",
	"r8",  "r9",  "r10", "r11",
	"r12", "r13", "r14", "r15",
	"ra"
};

int arch_ftrace_match(const char *name)
{
	return !strcmp(name, "__fentry__");
}

static int is_x86_64(const struct elf *elf)
{
	switch (elf->ehdr.e_machine) {
	case EM_X86_64:
		return 1;
	case EM_386:
		return 0;
	default:
		ERROR("unexpected ELF machine type %d", elf->ehdr.e_machine);
		return -1;
	}
}

bool arch_callee_saved_reg(unsigned char reg)
{
	switch (reg) {
	case CFI_BP:
	case CFI_BX:
	case CFI_R12:
	case CFI_R13:
	case CFI_R14:
	case CFI_R15:
		return true;

	case CFI_AX:
	case CFI_CX:
	case CFI_DX:
	case CFI_SI:
	case CFI_DI:
	case CFI_SP:
	case CFI_R8:
	case CFI_R9:
	case CFI_R10:
	case CFI_R11:
	case CFI_RA:
	default:
		return false;
	}
}

/* Undo the effects of __pa_symbol() if necessary */
static unsigned long phys_to_virt(unsigned long pa)
{
	s64 va = pa;

	if (va > 0)
		va &= ~(0x80000000);

	return va;
}

s64 arch_insn_adjusted_addend(struct instruction *insn, struct reloc *reloc)
{
	s64 addend = reloc_addend(reloc);

	if (arch_pc_relative_reloc(reloc))
		addend += insn->offset + insn->len - reloc_offset(reloc);

	return phys_to_virt(addend);
}

static void scan_for_insn(struct section *sec, unsigned long offset,
			  unsigned long *insn_off, unsigned int *insn_len)
{
	unsigned long o = 0;
	struct insn insn;

	while (1) {

		insn_decode(&insn, sec->data->d_buf + o, sec_size(sec) - o,
			    INSN_MODE_64);

		if (o + insn.length > offset) {
			*insn_off = o;
			*insn_len = insn.length;
			return;
		}

		o += insn.length;
	}
}

u64 arch_adjusted_addend(struct reloc *reloc)
{
	unsigned int type = reloc_type(reloc);
	s64 addend = reloc_addend(reloc);
	unsigned long insn_off;
	unsigned int insn_len;

	if (type == R_X86_64_PLT32)
		return addend + 4;

	if (type != R_X86_64_PC32 || !is_text_sec(reloc->sec->base))
		return addend;

	scan_for_insn(reloc->sec->base, reloc_offset(reloc),
		      &insn_off, &insn_len);

	return addend + insn_off + insn_len - reloc_offset(reloc);
}

unsigned long arch_jump_destination(struct instruction *insn)
{
	return insn->offset + insn->len + insn->immediate;
}

bool arch_pc_relative_reloc(struct reloc *reloc)
{
	/*
	 * All relocation types where P (the address of the target)
	 * is included in the computation.
	 */
	switch (reloc_type(reloc)) {
	case R_X86_64_PC8:
	case R_X86_64_PC16:
	case R_X86_64_PC32:
	case R_X86_64_PC64:

	case R_X86_64_PLT32:
	case R_X86_64_GOTPC32:
	case R_X86_64_GOTPCREL:
		return true;

	default:
		break;
	}

	return false;
}

#define ADD_OP(op) \
	if (!(op = calloc(1, sizeof(*op)))) \
		return -1; \
	else for (*ops_list = op, ops_list = &op->ne