[linux-block.git] / tools / objtool / orc_gen.c

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

#include <stdlib.h>
#include <string.h>

#include "orc.h"
#include "check.h"
#include "warn.h"

int create_orc(struct objtool_file *file)
{
	struct instruction *insn;

	for_each_insn(file, insn) {
		struct orc_entry *orc = &insn->orc;
		struct cfi_reg *cfa = &insn->state.cfa;
		struct cfi_reg *bp = &insn->state.regs[CFI_BP];

		orc->end = insn->state.end;

		if (cfa->base == CFI_UNDEFINED) {
			orc->sp_reg = ORC_REG_UNDEFINED;
			continue;
		}

		switch (cfa->base) {
		case CFI_SP:
			orc->sp_reg = ORC_REG_SP;
			break;
		case CFI_SP_INDIRECT:
			orc->sp_reg = ORC_REG_SP_INDIRECT;
			break;
		case CFI_BP:
			orc->sp_reg = ORC_REG_BP;
			break;
		case CFI_BP_INDIRECT:
			orc->sp_reg = ORC_REG_BP_INDIRECT;
			break;
		case CFI_R10:
			orc->sp_reg = ORC_REG_R10;
			break;
		case CFI_R13:
			orc->sp_reg = ORC_REG_R13;
			break;
		case CFI_DI:
			orc->sp_reg = ORC_REG_DI;
			break;
		case CFI_DX:
			orc->sp_reg = ORC_REG_DX;
			break;
		default:
			WARN_FUNC("unknown CFA base reg %d",
				  insn->sec, insn->offset, cfa->base);
			return -1;
		}

		switch(bp->base) {
		case CFI_UNDEFINED:
			orc->bp_reg = ORC_REG_UNDEFINED;
			break;
		case CFI_CFA:
			orc->bp_reg = ORC_REG_PREV_SP;
			break;
		case CFI_BP:
			orc->bp_reg = ORC_REG_BP;
			break;
		default:
			WARN_FUNC("unknown BP base reg %d",
				  insn->sec, insn->offset, bp->base);
			return -1;
		}

		orc->sp_offset = cfa->offset;
		orc->bp_offset = bp->offset;
		orc->type = insn->state.type;
	}

	return 0;
}

static int create_orc_entry(struct section *u_sec, struct section *ip_relasec,
				unsigned int idx, struct section *insn_sec,
				unsigned long insn_off, struct orc_entry *o)
{
	struct orc_entry *orc;
	struct rela *rela;

	if (!insn_sec->sym) {
		WARN("missing symbol for section %s", insn_sec->name);
		return -1;
	}

	/* populate ORC data */
	orc = (struct orc_entry *)u_sec->data->d_buf + idx;
	memcpy(orc, o, sizeof(*orc));

	/* populate rela for ip */
	rela = malloc(sizeof(*rela));
	if (!rela) {
		perror("malloc");
		return -1;
	}
	memset(rela, 0, sizeof(*rela));

	rela->sym = insn_sec->sym;
	rela->addend = insn_off;
	rela->type = R_X86_64_PC32;
	rela->offset = idx * sizeof(int);

	list_add_tail(&rela->list, &ip_relasec->rela_list);
	hash_add(ip_relasec->rela_hash, &rela->hash, rela->offset);

	return 0;
}

int create_orc_sections(struct objtool_file *file)
{
	struct instruction *insn, *prev_insn;
	struct section *sec, *u_sec, *ip_relasec;
	unsigned int idx;

	struct orc_entry empty = {
		.sp_reg = ORC_REG_UNDEFINED,
		.bp_reg  = ORC_REG_UNDEFINED,
		.type    = ORC_TYPE_CALL,
	};

	sec = find_section_by_name(file->elf, ".orc_unwind");
	if (sec) {
		WARN("file already has .orc_unwind section, skipping");
		return -1;
	}

	/* count the number of needed orcs */
	idx = 0;
	for_each_sec(file, sec) {
		if (!sec->text)
			continue;

		prev_insn = NULL;
		sec_for_each_insn(file, sec, insn) {
			if (!prev_insn ||
			    memcmp(&insn->orc, &prev_insn->orc,
				   sizeof(struct orc_entry))) {
				idx++;
			}
			prev_insn = insn;
		}

		/* section terminator */
		if (prev_insn)
			idx++;
	}
	if (!idx)
		return -1;


	/* create .orc_unwind_ip and .rela.orc_unwind_ip sections */
	sec = elf_create_section(file->elf, ".orc_unwind_ip", sizeof(int), idx);
	if (!sec)
		return -1;

	ip_relasec = elf_create_rela_section(file->elf, sec);
	if (!ip_relasec)
		return -1;

	/* create .orc_unwind section */
	u_sec = elf_create_section(file->elf, ".orc_unwind",
				   sizeof(struct orc_entry), idx);

	/* populate sections */
	idx = 0;
	for_each_sec(file, sec) {
		if (!sec->text)
			continue;

		prev_insn = NULL;
		sec_for_each_insn(file, sec, insn) {
			if (!prev_insn || memcmp(&insn->orc, &prev_insn->orc,
						 sizeof(struct orc_entry))) {

				if (create_orc_entry(u_sec, ip_relasec, idx,
						     insn->sec, insn->offset,
						     &insn->orc))
					return -1;

				idx++;
			}
			prev_insn = insn;
		}

		/* section terminator */
		if (prev_insn) {
			if (create_orc_entry(u_sec, ip_relasec, idx,
					     prev_insn->sec,
					     prev_insn->offset + prev_insn->len,
					     &empty))
				return -1;

			idx++;
		}
	}

	if (elf_rebuild_rela_section(ip_relasec))
		return -1;

	return 0;
}
Commit	Line	Data
1ccea77e	1	// SPDX-License-Identifier: GPL-2.0-or-later
627fce14 JP	2	/*
627fce14 JP	3	* Copyright (C) 2017 Josh Poimboeuf <jpoimboe@redhat.com>
627fce14 JP	4	*/
	5
	6	#include <stdlib.h>
	7	#include <string.h>
	8
	9	#include "orc.h"
	10	#include "check.h"
	11	#include "warn.h"
	12
	13	int create_orc(struct objtool_file *file)
	14	{
	15	struct instruction *insn;
	16
	17	for_each_insn(file, insn) {
	18	struct orc_entry *orc = &insn->orc;
	19	struct cfi_reg *cfa = &insn->state.cfa;
	20	struct cfi_reg *bp = &insn->state.regs[CFI_BP];
	21
d31a5802 JP	22	orc->end = insn->state.end;
d31a5802 JP	23
627fce14 JP	24	if (cfa->base == CFI_UNDEFINED) {
	25	orc->sp_reg = ORC_REG_UNDEFINED;
	26	continue;
	27	}
	28
	29	switch (cfa->base) {
	30	case CFI_SP:
	31	orc->sp_reg = ORC_REG_SP;
	32	break;
	33	case CFI_SP_INDIRECT:
	34	orc->sp_reg = ORC_REG_SP_INDIRECT;
	35	break;
	36	case CFI_BP:
	37	orc->sp_reg = ORC_REG_BP;
	38	break;
	39	case CFI_BP_INDIRECT:
	40	orc->sp_reg = ORC_REG_BP_INDIRECT;
	41	break;
	42	case CFI_R10:
	43	orc->sp_reg = ORC_REG_R10;
	44	break;
	45	case CFI_R13:
	46	orc->sp_reg = ORC_REG_R13;
	47	break;
	48	case CFI_DI:
	49	orc->sp_reg = ORC_REG_DI;
	50	break;
	51	case CFI_DX:
	52	orc->sp_reg = ORC_REG_DX;
	53	break;
	54	default:
	55	WARN_FUNC("unknown CFA base reg %d",
	56	insn->sec, insn->offset, cfa->base);
	57	return -1;
	58	}
	59
	60	switch(bp->base) {
	61	case CFI_UNDEFINED:
	62	orc->bp_reg = ORC_REG_UNDEFINED;
	63	break;
	64	case CFI_CFA:
	65	orc->bp_reg = ORC_REG_PREV_SP;
	66	break;
	67	case CFI_BP:
	68	orc->bp_reg = ORC_REG_BP;
	69	break;
	70	default:
	71	WARN_FUNC("unknown BP base reg %d",
	72	insn->sec, insn->offset, bp->base);
	73	return -1;
	74	}
	75
	76	orc->sp_offset = cfa->offset;
	77	orc->bp_offset = bp->offset;
	78	orc->type = insn->state.type;
	79	}
	80
	81	return 0;
	82	}
	83
	84	static int create_orc_entry(struct section u_sec, struct section ip_relasec,
	85	unsigned int idx, struct section *insn_sec,
	86	unsigned long insn_off, struct orc_entry *o)
	87	{
88	struct orc_entry *orc;
89	struct rela *rela;
90
830c1e3d JP	91	if (!insn_sec->sym) {
	92	WARN("missing symbol for section %s", insn_sec->name);
	93	return -1;
	94	}
	95
627fce14 JP	96	/* populate ORC data */
	97	orc = (struct orc_entry *)u_sec->data->d_buf + idx;
	98	memcpy(orc, o, sizeof(*orc));
	99
	100	/* populate rela for ip */
	101	rela = malloc(sizeof(*rela));
	102	if (!rela) {
	103	perror("malloc");
	104	return -1;
	105	}
	106	memset(rela, 0, sizeof(*rela));
	107
	108	rela->sym = insn_sec->sym;
	109	rela->addend = insn_off;
	110	rela->type = R_X86_64_PC32;
	111	rela->offset = idx * sizeof(int);
	112
	113	list_add_tail(&rela->list, &ip_relasec->rela_list);
	114	hash_add(ip_relasec->rela_hash, &rela->hash, rela->offset);
	115
	116	return 0;
	117	}
	118
	119	int create_orc_sections(struct objtool_file *file)
	120	{
	121	struct instruction insn, prev_insn;
	122	struct section sec, u_sec, *ip_relasec;
	123	unsigned int idx;
	124
	125	struct orc_entry empty = {
	126	.sp_reg = ORC_REG_UNDEFINED,
	127	.bp_reg = ORC_REG_UNDEFINED,
	128	.type = ORC_TYPE_CALL,
	129	};
	130
	131	sec = find_section_by_name(file->elf, ".orc_unwind");
	132	if (sec) {
	133	WARN("file already has .orc_unwind section, skipping");
	134	return -1;
	135	}
	136
	137	/* count the number of needed orcs */
	138	idx = 0;
	139	for_each_sec(file, sec) {
	140	if (!sec->text)
	141	continue;
	142
	143	prev_insn = NULL;
	144	sec_for_each_insn(file, sec, insn) {
	145	if (!prev_insn \|\|
	146	memcmp(&insn->orc, &prev_insn->orc,
	147	sizeof(struct orc_entry))) {
	148	idx++;
	149	}
	150	prev_insn = insn;
	151	}
	152
	153	/* section terminator */
	154	if (prev_insn)
	155	idx++;
	156	}
	157	if (!idx)
	158	return -1;
	159
160
161	/* create .orc_unwind_ip and .rela.orc_unwind_ip sections */
162	sec = elf_create_section(file->elf, ".orc_unwind_ip", sizeof(int), idx);
ce90aaf5 SS	163	if (!sec)
ce90aaf5 SS	164	return -1;
627fce14 JP	165
	166	ip_relasec = elf_create_rela_section(file->elf, sec);
	167	if (!ip_relasec)
	168	return -1;
	169
	170	/* create .orc_unwind section */
	171	u_sec = elf_create_section(file->elf, ".orc_unwind",
	172	sizeof(struct orc_entry), idx);
	173
	174	/* populate sections */
	175	idx = 0;
	176	for_each_sec(file, sec) {
	177	if (!sec->text)
	178	continue;
	179
	180	prev_insn = NULL;
	181	sec_for_each_insn(file, sec, insn) {
	182	if (!prev_insn \|\| memcmp(&insn->orc, &prev_insn->orc,
	183	sizeof(struct orc_entry))) {
	184
	185	if (create_orc_entry(u_sec, ip_relasec, idx,
	186	insn->sec, insn->offset,
	187	&insn->orc))
	188	return -1;
	189
	190	idx++;
	191	}
	192	prev_insn = insn;
	193	}
	194
	195	/* section terminator */
	196	if (prev_insn) {
	197	if (create_orc_entry(u_sec, ip_relasec, idx,
	198	prev_insn->sec,
	199	prev_insn->offset + prev_insn->len,
	200	&empty))
	201	return -1;
	202
	203	idx++;
	204	}
	205	}
	206
	207	if (elf_rebuild_rela_section(ip_relasec))
	208	return -1;
	209
	210	return 0;
	211	}