[mirror_ubuntu-artful-kernel.git] / tools / objtool / orc_gen.c

/*
 * Copyright (C) 2017 Josh Poimboeuf <jpoimboe@redhat.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#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];

		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;

	/* 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);

	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
9460f776 JP	1	/*
	2	* Copyright (C) 2017 Josh Poimboeuf <jpoimboe@redhat.com>
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public License
	6	* as published by the Free Software Foundation; either version 2
	7	* of the License, or (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, see <http://www.gnu.org/licenses/>.
	16	*/
	17
	18	#include <stdlib.h>
	19	#include <string.h>
	20
	21	#include "orc.h"
	22	#include "check.h"
	23	#include "warn.h"
	24
	25	int create_orc(struct objtool_file *file)
	26	{
	27	struct instruction *insn;
	28
	29	for_each_insn(file, insn) {
	30	struct orc_entry *orc = &insn->orc;
	31	struct cfi_reg *cfa = &insn->state.cfa;
	32	struct cfi_reg *bp = &insn->state.regs[CFI_BP];
	33
	34	if (cfa->base == CFI_UNDEFINED) {
	35	orc->sp_reg = ORC_REG_UNDEFINED;
	36	continue;
	37	}
	38
	39	switch (cfa->base) {
	40	case CFI_SP:
	41	orc->sp_reg = ORC_REG_SP;
	42	break;
	43	case CFI_SP_INDIRECT:
	44	orc->sp_reg = ORC_REG_SP_INDIRECT;
	45	break;
	46	case CFI_BP:
	47	orc->sp_reg = ORC_REG_BP;
	48	break;
	49	case CFI_BP_INDIRECT:
	50	orc->sp_reg = ORC_REG_BP_INDIRECT;
	51	break;
	52	case CFI_R10:
	53	orc->sp_reg = ORC_REG_R10;
	54	break;
	55	case CFI_R13:
	56	orc->sp_reg = ORC_REG_R13;
	57	break;
	58	case CFI_DI:
	59	orc->sp_reg = ORC_REG_DI;
	60	break;
	61	case CFI_DX:
	62	orc->sp_reg = ORC_REG_DX;
	63	break;
	64	default:
65	WARN_FUNC("unknown CFA base reg %d",
66	insn->sec, insn->offset, cfa->base);
67	return -1;
68	}
69
70	switch(bp->base) {
71	case CFI_UNDEFINED:
72	orc->bp_reg = ORC_REG_UNDEFINED;
73	break;
74	case CFI_CFA:
75	orc->bp_reg = ORC_REG_PREV_SP;
76	break;
77	case CFI_BP:
78	orc->bp_reg = ORC_REG_BP;
79	break;
80	default:
81	WARN_FUNC("unknown BP base reg %d",
82	insn->sec, insn->offset, bp->base);
83	return -1;
84	}
85
86	orc->sp_offset = cfa->offset;
87	orc->bp_offset = bp->offset;
88	orc->type = insn->state.type;
89	}
90
91	return 0;
92	}
93
94	static int create_orc_entry(struct section u_sec, struct section ip_relasec,
95	unsigned int idx, struct section *insn_sec,
96	unsigned long insn_off, struct orc_entry *o)
97	{
98	struct orc_entry *orc;
99	struct rela *rela;
100
101	/* populate ORC data */
102	orc = (struct orc_entry *)u_sec->data->d_buf + idx;
103	memcpy(orc, o, sizeof(*orc));
104
105	/* populate rela for ip */
106	rela = malloc(sizeof(*rela));
107	if (!rela) {
108	perror("malloc");
109	return -1;
110	}
111	memset(rela, 0, sizeof(*rela));
112
113	rela->sym = insn_sec->sym;
114	rela->addend = insn_off;
115	rela->type = R_X86_64_PC32;
116	rela->offset = idx * sizeof(int);
117
118	list_add_tail(&rela->list, &ip_relasec->rela_list);
119	hash_add(ip_relasec->rela_hash, &rela->hash, rela->offset);
120
121	return 0;
122	}
123
124	int create_orc_sections(struct objtool_file *file)
125	{
126	struct instruction insn, prev_insn;
127	struct section sec, u_sec, *ip_relasec;
128	unsigned int idx;
129
130	struct orc_entry empty = {
131	.sp_reg = ORC_REG_UNDEFINED,
132	.bp_reg = ORC_REG_UNDEFINED,
133	.type = ORC_TYPE_CALL,
134	};
135
136	sec = find_section_by_name(file->elf, ".orc_unwind");
137	if (sec) {
138	WARN("file already has .orc_unwind section, skipping");
139	return -1;
140	}
141
142	/* count the number of needed orcs */
143	idx = 0;
144	for_each_sec(file, sec) {
145	if (!sec->text)
146	continue;
147
148	prev_insn = NULL;
149	sec_for_each_insn(file, sec, insn) {
150	if (!prev_insn \|\|
151	memcmp(&insn->orc, &prev_insn->orc,
152	sizeof(struct orc_entry))) {
153	idx++;
154	}
155	prev_insn = insn;
156	}
157
158	/* section terminator */
159	if (prev_insn)
160	idx++;
161	}
162	if (!idx)
163	return -1;
164
165
166	/* create .orc_unwind_ip and .rela.orc_unwind_ip sections */
167	sec = elf_create_section(file->elf, ".orc_unwind_ip", sizeof(int), idx);
168
169	ip_relasec = elf_create_rela_section(file->elf, sec);
170	if (!ip_relasec)
171	return -1;
172
173	/* create .orc_unwind section */
174	u_sec = elf_create_section(file->elf, ".orc_unwind",
175	sizeof(struct orc_entry), idx);
176
177	/* populate sections */
178	idx = 0;
179	for_each_sec(file, sec) {
180	if (!sec->text)
181	continue;
182
183	prev_insn = NULL;
184	sec_for_each_insn(file, sec, insn) {
185	if (!prev_insn \|\| memcmp(&insn->orc, &prev_insn->orc,
186	sizeof(struct orc_entry))) {
187
188	if (create_orc_entry(u_sec, ip_relasec, idx,
189	insn->sec, insn->offset,
190	&insn->orc))
191	return -1;
192
193	idx++;
194	}
195	prev_insn = insn;
196	}
197
198	/* section terminator */
199	if (prev_insn) {
200	if (create_orc_entry(u_sec, ip_relasec, idx,
201	prev_insn->sec,
202	prev_insn->offset + prev_insn->len,
203	&empty))
204	return -1;
205
206	idx++;
207	}
208	}
209
210	if (elf_rebuild_rela_section(ip_relasec))
211	return -1;
212
213	return 0;
214	}