[mirror_ubuntu-focal-kernel.git] / tools / objtool / elf.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * elf.c - ELF access library
 *
 * Adapted from kpatch (https://github.com/dynup/kpatch):
 * Copyright (C) 2013-2015 Josh Poimboeuf <jpoimboe@redhat.com>
 * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

#include "elf.h"
#include "warn.h"

#define MAX_NAME_LEN 128

struct section *find_section_by_name(struct elf *elf, const char *name)
{
	struct section *sec;

	list_for_each_entry(sec, &elf->sections, list)
		if (!strcmp(sec->name, name))
			return sec;

	return NULL;
}

static struct section *find_section_by_index(struct elf *elf,
					     unsigned int idx)
{
	struct section *sec;

	list_for_each_entry(sec, &elf->sections, list)
		if (sec->idx == idx)
			return sec;

	return NULL;
}

static struct symbol *find_symbol_by_index(struct elf *elf, unsigned int idx)
{
	struct section *sec;
	struct symbol *sym;

	list_for_each_entry(sec, &elf->sections, list)
		hash_for_each_possible(sec->symbol_hash, sym, hash, idx)
			if (sym->idx == idx)
				return sym;

	return NULL;
}

struct symbol *find_symbol_by_offset(struct section *sec, unsigned long offset)
{
	struct symbol *sym;

	list_for_each_entry(sym, &sec->symbol_list, list)
		if (sym->type != STT_SECTION &&
		    sym->offset == offset)
			return sym;

	return NULL;
}

struct symbol *find_symbol_by_name(struct elf *elf, const char *name)
{
	struct section *sec;
	struct symbol *sym;

	list_for_each_entry(sec, &elf->sections, list)
		list_for_each_entry(sym, &sec->symbol_list, list)
			if (!strcmp(sym->name, name))
				return sym;

	return NULL;
}

struct symbol *find_symbol_containing(struct section *sec, unsigned long offset)
{
	struct symbol *sym;

	list_for_each_entry(sym, &sec->symbol_list, list)
		if (sym->type != STT_SECTION &&
		    offset >= sym->offset && offset < sym->offset + sym->len)
			return sym;

	return NULL;
}

struct rela *find_rela_by_dest_range(struct section *sec, unsigned long offset,
				     unsigned int len)
{
	struct rela *rela;
	unsigned long o;

	if (!sec->rela)
		return NULL;

	for (o = offset; o < offset + len; o++)
		hash_for_each_possible(sec->rela->rela_hash, rela, hash, o)
			if (rela->offset == o)
				return rela;

	return NULL;
}

struct rela *find_rela_by_dest(struct section *sec, unsigned long offset)
{
	return find_rela_by_dest_range(sec, offset, 1);
}

struct symbol *find_containing_func(struct section *sec, unsigned long offset)
{
	struct symbol *func;

	list_for_each_entry(func, &sec->symbol_list, list)
		if (func->type == STT_FUNC && offset >= func->offset &&
		    offset < func->offset + func->len)
			return func;

	return NULL;
}

static int read_sections(struct elf *elf)
{
	Elf_Scn *s = NULL;
	struct section *sec;
	size_t shstrndx, sections_nr;
	int i;

	if (elf_getshdrnum(elf->elf, &sections_nr)) {
		WARN_ELF("elf_getshdrnum");
		return -1;
	}

	if (elf_getshdrstrndx(elf->elf, &shstrndx)) {
		WARN_ELF("elf_getshdrstrndx");
		return -1;
	}

	for (i = 0; i < sections_nr; i++) {
		sec = malloc(sizeof(*sec));
		if (!sec) {
			perror("malloc");
			return -1;
		}
		memset(sec, 0, sizeof(*sec));

		INIT_LIST_HEAD(&sec->symbol_list);
		INIT_LIST_HEAD(&sec->rela_list);
		hash_init(sec->rela_hash);
		hash_init(sec->symbol_hash);

		list_add_tail(&sec->list, &elf->sections);

		s = elf_getscn(elf->elf, i);
		if (!s) {
			WARN_ELF("elf_getscn");
			return -1;
		}

		sec->idx = elf_ndxscn(s);

		if (!gelf_getshdr(s, &sec->sh)) {
			WARN_ELF("gelf_getshdr");
			return -1;
		}

		sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name);
		if (!sec->name) {
			WARN_ELF("elf_strptr");
			return -1;
		}

		if (sec->sh.sh_size != 0) {
			sec->data = elf_getdata(s, NULL);
			if (!sec->data) {
				WARN_ELF("elf_getdata");
				return -1;
			}
			if (sec->data->d_off != 0 ||
			    sec->data->d_size != sec->sh.sh_size) {
				WARN("unexpected data attributes for %s",
				     sec->name);
				return -1;
			}
		}
		sec->len = sec->sh.sh_size;
	}

	/* sanity check, one more call to elf_nextscn() should return NULL */
	if (elf_nextscn(elf->elf, s)) {
		WARN("section entry mismatch");
		return -1;
	}

	return 0;
}

static int read_symbols(struct elf *elf)
{
	struct section *symtab, *sec;
	struct symbol *sym, *pfunc, *alias;
	struct list_head *entry, *tmp;
	int symbols_nr, i;
	char *coldstr;

	symtab = find_section_by_name(elf, ".symtab");
	if (!symtab) {
		/*
		 * A missing symbol table is actually possible if it's an empty
		 * .o file.  This can happen for thunk_64.o.
		 */
		return 0;
	}

	symbols_nr = symtab->sh.sh_size / symtab->sh.sh_entsize;

	for (i = 0; i < symbols_nr; i++) {
		sym = malloc(sizeof(*sym));
		if (!sym) {
			perror("malloc");
			return -1;
		}
		memset(sym, 0, sizeof(*sym));
		alias = sym;

		sym->idx = i;

		if (!gelf_getsym(symtab->data, i, &sym->sym)) {
			WARN_ELF("gelf_getsym");
			goto err;
		}

		sym->name = elf_strptr(elf->elf, symtab->sh.sh_link,
				       sym->sym.st_name);
		if (!sym->name) {
			WARN_ELF("elf_strptr");
			goto err;
		}

		sym->type = GELF_ST_TYPE(sym->sym.st_info);
		sym->bind = GELF_ST_BIND(sym->sym.st_info);

		if (sym->sym.st_shndx > SHN_UNDEF &&
		    sym->sym.st_shndx < SHN_LORESERVE) {
			sym->sec = find_section_by_index(elf,
							 sym->sym.st_shndx);
			if (!sym->sec) {
				WARN("couldn't find section for symbol %s",
				     sym->name);
				goto err;
			}
			if (sym->type == STT_SECTION) {
				sym->name = sym->sec->name;
				sym->sec->sym = sym;
			}
		} else
			sym->sec = find_section_by_index(elf, 0);

		sym->offset = sym->sym.st_value;
		sym->len = sym->sym.st_size;

		/* sorted insert into a per-section list */
		entry = &sym->sec->symbol_list;
		list_for_each_prev(tmp, &sym->sec->symbol_list) {
			struct symbol *s;

			s = list_entry(tmp, struct symbol, list);

			if (sym->offset > s->offset) {
				entry = tmp;
				break;
			}

			if (sym->offset == s->offset) {
				if (sym->len && sym->len == s->len && alias == sym)
					alias = s;

				if (sym->len >= s->len) {
					entry = tmp;
					break;
				}
			}
		}
		sym->alias = alias;
		list_add(&sym->list, entry);
		hash_add(sym->sec->symbol_hash, &sym->hash, sym->idx);
	}

	/* Create parent/child links for any cold subfunctions */
	list_for_each_entry(sec, &elf->sections, list) {
		list_for_each_entry(sym, &sec->symbol_list, list) {
			char pname[MAX_NAME_LEN + 1];
			size_t pnamelen;
			if (sym->type != STT_FUNC)
				continue;
			sym->pfunc = sym->cfunc = sym;
			coldstr = strstr(sym->name, ".cold");
			if (!coldstr)
				continue;

			pnamelen = coldstr - sym->name;
			if (pnamelen > MAX_NAME_LEN) {
				WARN("%s(): parent function name exceeds maximum length of %d characters",
				     sym->name, MAX_NAME_LEN);
				return -1;
			}

			strncpy(pname, sym->name, pnamelen);
			pname[pnamelen] = '\0';
			pfunc = find_symbol_by_name(elf, pname);

			if (!pfunc) {
				WARN("%s(): can't find parent function",
				     sym->name);
				return -1;
			}

			sym->pfunc = pfunc;
			pfunc->cfunc = sym;

			/*
			 * Unfortunately, -fnoreorder-functions puts the child
			 * inside the parent.  Remove the overlap so we can
			 * have sane assumptions.
			 *
			 * Note that pfunc->len now no longer matches
			 * pfunc->sym.st_size.
			 */
			if (sym->sec == pfunc->sec &&
			    sym->offset >= pfunc->offset &&
			    sym->offset + sym->len == pfunc->offset + pfunc->len) {
				pfunc->len -= sym->len;
			}
		}
	}

	return 0;

err:
	free(sym);
	return -1;
}

static int read_relas(struct elf *elf)
{
	struct section *sec;
	struct rela *rela;
	int i;
	unsigned int symndx;

	list_for_each_entry(sec, &elf->sections, list) {
		if (sec->sh.sh_type != SHT_RELA)
			continue;

		sec->base = find_section_by_name(elf, sec->name + 5);
		if (!sec->base) {
			WARN("can't find base section for rela section %s",
			     sec->name);
			return -1;
		}

		sec->base->rela = sec;

		for (i = 0; i < sec->sh.sh_size / sec->sh.sh_entsize; i++) {
			rela = malloc(sizeof(*rela));
			if (!rela) {
				perror("malloc");
				return -1;
			}
			memset(rela, 0, sizeof(*rela));

			if (!gelf_getrela(sec->data, i, &rela->rela)) {
				WARN_ELF("gelf_getrela");
				return -1;
			}

			rela->type = GELF_R_TYPE(rela->rela.r_info);
			rela->addend = rela->rela.r_addend;
			rela->offset = rela->rela.r_offset;
			symndx = GELF_R_SYM(rela->rela.r_info);
			rela->sym = find_symbol_by_index(elf, symndx);
			rela->sec = sec;
			if (!rela->sym) {
				WARN("can't find rela entry symbol %d for %s",
				     symndx, sec->name);
				return -1;
			}

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

		}
	}

	return 0;
}

struct elf *elf_read(const char *name, int flags)
{
	struct elf *elf;
	Elf_Cmd cmd;

	elf_version(EV_CURRENT);

	elf = malloc(sizeof(*elf));
	if (!elf) {
		perror("malloc");
		return NULL;
	}
	memset(elf, 0, sizeof(*elf));

	INIT_LIST_HEAD(&elf->sections);

	elf->fd = open(name, flags);
	if (elf->fd == -1) {
		fprintf(stderr, "objtool: Can't open '%s': %s\n",
			name, strerror(errno));
		goto err;
	}

	if ((flags & O_ACCMODE) == O_RDONLY)
		cmd = ELF_C_READ_MMAP;
	else if ((flags & O_ACCMODE) == O_RDWR)
		cmd = ELF_C_RDWR;
	else /* O_WRONLY */
		cmd = ELF_C_WRITE;

	elf->elf = elf_begin(elf->fd, cmd, NULL);
	if (!elf->elf) {
		WARN_ELF("elf_begin");
		goto err;
	}

	if (!gelf_getehdr(elf->elf, &elf->ehdr)) {
		WARN_ELF("gelf_getehdr");
		goto err;
	}

	if (read_sections(elf))
		goto err;

	if (read_symbols(elf))
		goto err;

	if (read_relas(elf))
		goto err;

	return elf;

err:
	elf_close(elf);
	return NULL;
}

struct section *elf_create_section(struct elf *elf, const char *name,
				   size_t entsize, int nr)
{
	struct section *sec, *shstrtab;
	size_t size = entsize * nr;
	Elf_Scn *s;
	Elf_Data *data;

	sec = malloc(sizeof(*sec));
	if (!sec) {
		perror("malloc");
		return NULL;
	}
	memset(sec, 0, sizeof(*sec));

	INIT_LIST_HEAD(&sec->symbol_list);
	INIT_LIST_HEAD(&sec->rela_list);
	hash_init(sec->rela_hash);
	hash_init(sec->symbol_hash);

	list_add_tail(&sec->list, &elf->sections);

	s = elf_newscn(elf->elf);
	if (!s) {
		WARN_ELF("elf_newscn");
		return NULL;
	}

	sec->name = strdup(name);
	if (!sec->name) {
		perror("strdup");
		return NULL;
	}

	sec->idx = elf_ndxscn(s);
	sec->len = size;
	sec->changed = true;

	sec->data = elf_newdata(s);
	if (!sec->data) {
		WARN_ELF("elf_newdata");
		return NULL;
	}

	sec->data->d_size = size;
	sec->data->d_align = 1;

	if (size) {
		sec->data->d_buf = malloc(size);
		if (!sec->data->d_buf) {
			perror("malloc");
			return NULL;
		}
		memset(sec->data->d_buf, 0, size);
	}

	if (!gelf_getshdr(s, &sec->sh)) {
		WARN_ELF("gelf_getshdr");
		return NULL;
	}

	sec->sh.sh_size = size;
	sec->sh.sh_entsize = entsize;
	sec->sh.sh_type = SHT_PROGBITS;
	sec->sh.sh_addralign = 1;
	sec->sh.sh_flags = SHF_ALLOC;


	/* Add section name to .shstrtab (or .strtab for Clang) */
	shstrtab = find_section_by_name(elf, ".shstrtab");
	if (!shstrtab)
		shstrtab = find_section_by_name(elf, ".strtab");
	if (!shstrtab) {
		WARN("can't find .shstrtab or .strtab section");
		return NULL;
	}

	s = elf_getscn(elf->elf, shstrtab->idx);
	if (!s) {
		WARN_ELF("elf_getscn");
		return NULL;
	}

	data = elf_newdata(s);
	if (!data) {
		WARN_ELF("elf_newdata");
		return NULL;
	}

	data->d_buf = sec->name;
	data->d_size = strlen(name) + 1;
	data->d_align = 1;

	sec->sh.sh_name = shstrtab->len;

	shstrtab->len += strlen(name) + 1;
	shstrtab->changed = true;

	return sec;
}

struct section *elf_create_rela_section(struct elf *elf, struct section *base)
{
	char *relaname;
	struct section *sec;

	relaname = malloc(strlen(base->name) + strlen(".rela") + 1);
	if (!relaname) {
		perror("malloc");
		return NULL;
	}
	strcpy(relaname, ".rela");
	strcat(relaname, base->name);

	sec = elf_create_section(elf, relaname, sizeof(GElf_Rela), 0);
	free(relaname);
	if (!sec)
		return NULL;

	base->rela = sec;
	sec->base = base;

	sec->sh.sh_type = SHT_RELA;
	sec->sh.sh_addralign = 8;
	sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx;
	sec->sh.sh_info = base->idx;
	sec->sh.sh_flags = SHF_INFO_LINK;

	return sec;
}

int elf_rebuild_rela_section(struct section *sec)
{
	struct rela *rela;
	int nr, idx = 0, size;
	GElf_Rela *relas;

	nr = 0;
	list_for_each_entry(rela, &sec->rela_list, list)
		nr++;

	size = nr * sizeof(*relas);
	relas = malloc(size);
	if (!relas) {
		perror("malloc");
		return -1;
	}

	sec->data->d_buf = relas;
	sec->data->d_size = size;

	sec->sh.sh_size = size;

	idx = 0;
	list_for_each_entry(rela, &sec->rela_list, list) {
		relas[idx].r_offset = rela->offset;
		relas[idx].r_addend = rela->addend;
		relas[idx].r_info = GELF_R_INFO(rela->sym->idx, rela->type);
		idx++;
	}

	return 0;
}

int elf_write(struct elf *elf)
{
	struct section *sec;
	Elf_Scn *s;

	/* Update section headers for changed sections: */
	list_for_each_entry(sec, &elf->sections, list) {
		if (sec->changed) {
			s = elf_getscn(elf->elf, sec->idx);
			if (!s) {
				WARN_ELF("elf_getscn");
				return -1;
			}
			if (!gelf_update_shdr(s, &sec->sh)) {
				WARN_ELF("gelf_update_shdr");
				return -1;
			}
		}
	}

	/* Make sure the new section header entries get updated properly. */
	elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY);

	/* Write all changes to the file. */
	if (elf_update(elf->elf, ELF_C_WRITE) < 0) {
		WARN_ELF("elf_update");
		return -1;
	}

	return 0;
}

void elf_close(struct elf *elf)
{
	struct section *sec, *tmpsec;
	struct symbol *sym, *tmpsym;
	struct rela *rela, *tmprela;

	if (elf->elf)
		elf_end(elf->elf);

	if (elf->fd > 0)
		close(elf->fd);

	list_for_each_entry_safe(sec, tmpsec, &elf->sections, list) {
		list_for_each_entry_safe(sym, tmpsym, &sec->symbol_list, list) {
			list_del(&sym->list);
			hash_del(&sym->hash);
			free(sym);
		}
		list_for_each_entry_safe(rela, tmprela, &sec->rela_list, list) {
			list_del(&rela->list);
			hash_del(&rela->hash);
			free(rela);
		}
		list_del(&sec->list);
		free(sec);
	}

	free(elf);
}
Commit	Line	Data
1ccea77e	1	// SPDX-License-Identifier: GPL-2.0-or-later
442f04c3 JP	2	/*
	3	* elf.c - ELF access library
	4	*
	5	* Adapted from kpatch (https://github.com/dynup/kpatch):
	6	* Copyright (C) 2013-2015 Josh Poimboeuf <jpoimboe@redhat.com>
	7	* Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
442f04c3 JP	8	*/
	9
	10	#include <sys/types.h>
	11	#include <sys/stat.h>
	12	#include <fcntl.h>
	13	#include <stdio.h>
	14	#include <stdlib.h>
	15	#include <string.h>
	16	#include <unistd.h>
385d11b1	17	#include <errno.h>
442f04c3 JP	18
	19	#include "elf.h"
	20	#include "warn.h"
	21
22566c16 AS	22	#define MAX_NAME_LEN 128
22566c16 AS	23
442f04c3 JP	24	struct section find_section_by_name(struct elf elf, const char *name)
	25	{
	26	struct section *sec;
	27
	28	list_for_each_entry(sec, &elf->sections, list)
	29	if (!strcmp(sec->name, name))
	30	return sec;
	31
	32	return NULL;
	33	}
	34
	35	static struct section find_section_by_index(struct elf elf,
	36	unsigned int idx)
	37	{
	38	struct section *sec;
	39
	40	list_for_each_entry(sec, &elf->sections, list)
	41	if (sec->idx == idx)
	42	return sec;
	43
	44	return NULL;
	45	}
	46
	47	static struct symbol find_symbol_by_index(struct elf elf, unsigned int idx)
	48	{
	49	struct section *sec;
	50	struct symbol *sym;
	51
	52	list_for_each_entry(sec, &elf->sections, list)
042ba73f	53	hash_for_each_possible(sec->symbol_hash, sym, hash, idx)
442f04c3 JP	54	if (sym->idx == idx)
	55	return sym;
	56
	57	return NULL;
	58	}
	59
	60	struct symbol find_symbol_by_offset(struct section sec, unsigned long offset)
	61	{
	62	struct symbol *sym;
	63
a196e171	64	list_for_each_entry(sym, &sec->symbol_list, list)
442f04c3 JP	65	if (sym->type != STT_SECTION &&
	66	sym->offset == offset)
	67	return sym;
	68
	69	return NULL;
	70	}
	71
13810435 JP	72	struct symbol find_symbol_by_name(struct elf elf, const char *name)
	73	{
	74	struct section *sec;
	75	struct symbol *sym;
	76
	77	list_for_each_entry(sec, &elf->sections, list)
	78	list_for_each_entry(sym, &sec->symbol_list, list)
	79	if (!strcmp(sym->name, name))
	80	return sym;
	81
	82	return NULL;
	83	}
	84
5c51f4ae JP	85	struct symbol find_symbol_containing(struct section sec, unsigned long offset)
	86	{
	87	struct symbol *sym;
	88
	89	list_for_each_entry(sym, &sec->symbol_list, list)
	90	if (sym->type != STT_SECTION &&
	91	offset >= sym->offset && offset < sym->offset + sym->len)
	92	return sym;
	93
	94	return NULL;
	95	}
	96
442f04c3 JP	97	struct rela find_rela_by_dest_range(struct section sec, unsigned long offset,
	98	unsigned int len)
	99	{
	100	struct rela *rela;
042ba73f	101	unsigned long o;
442f04c3 JP	102
	103	if (!sec->rela)
	104	return NULL;
	105
042ba73f JP	106	for (o = offset; o < offset + len; o++)
	107	hash_for_each_possible(sec->rela->rela_hash, rela, hash, o)
	108	if (rela->offset == o)
	109	return rela;
442f04c3 JP	110
	111	return NULL;
	112	}
	113
	114	struct rela find_rela_by_dest(struct section sec, unsigned long offset)
	115	{
	116	return find_rela_by_dest_range(sec, offset, 1);
	117	}
	118
	119	struct symbol find_containing_func(struct section sec, unsigned long offset)
	120	{
	121	struct symbol *func;
	122
a196e171	123	list_for_each_entry(func, &sec->symbol_list, list)
442f04c3 JP	124	if (func->type == STT_FUNC && offset >= func->offset &&
	125	offset < func->offset + func->len)
	126	return func;
	127
	128	return NULL;
	129	}
	130
	131	static int read_sections(struct elf *elf)
	132	{
	133	Elf_Scn *s = NULL;
	134	struct section *sec;
	135	size_t shstrndx, sections_nr;
	136	int i;
	137
	138	if (elf_getshdrnum(elf->elf, &sections_nr)) {
baa41469	139	WARN_ELF("elf_getshdrnum");
442f04c3 JP	140	return -1;
	141	}
	142
	143	if (elf_getshdrstrndx(elf->elf, &shstrndx)) {
baa41469	144	WARN_ELF("elf_getshdrstrndx");
442f04c3 JP	145	return -1;
	146	}
	147
	148	for (i = 0; i < sections_nr; i++) {
	149	sec = malloc(sizeof(*sec));
	150	if (!sec) {
	151	perror("malloc");
	152	return -1;
	153	}
	154	memset(sec, 0, sizeof(*sec));
	155
a196e171 JP	156	INIT_LIST_HEAD(&sec->symbol_list);
a196e171 JP	157	INIT_LIST_HEAD(&sec->rela_list);
042ba73f JP	158	hash_init(sec->rela_hash);
042ba73f JP	159	hash_init(sec->symbol_hash);
442f04c3 JP	160
	161	list_add_tail(&sec->list, &elf->sections);
	162
	163	s = elf_getscn(elf->elf, i);
	164	if (!s) {
baa41469	165	WARN_ELF("elf_getscn");
442f04c3 JP	166	return -1;
	167	}
	168
	169	sec->idx = elf_ndxscn(s);
	170
	171	if (!gelf_getshdr(s, &sec->sh)) {
baa41469	172	WARN_ELF("gelf_getshdr");
442f04c3 JP	173	return -1;
	174	}
	175
	176	sec->name = elf_strptr(elf->elf, shstrndx, sec->sh.sh_name);
	177	if (!sec->name) {
baa41469	178	WARN_ELF("elf_strptr");
442f04c3 JP	179	return -1;
	180	}
	181
df968c93 PV	182	if (sec->sh.sh_size != 0) {
	183	sec->data = elf_getdata(s, NULL);
	184	if (!sec->data) {
	185	WARN_ELF("elf_getdata");
	186	return -1;
	187	}
	188	if (sec->data->d_off != 0 \|\|
	189	sec->data->d_size != sec->sh.sh_size) {
	190	WARN("unexpected data attributes for %s",
	191	sec->name);
	192	return -1;
	193	}
442f04c3	194	}
df968c93	195	sec->len = sec->sh.sh_size;
442f04c3 JP	196	}
	197
	198	/* sanity check, one more call to elf_nextscn() should return NULL */
	199	if (elf_nextscn(elf->elf, s)) {
	200	WARN("section entry mismatch");
	201	return -1;
	202	}
	203
	204	return 0;
	205	}
	206
	207	static int read_symbols(struct elf *elf)
	208	{
13810435	209	struct section symtab, sec;
09f30d83	210	struct symbol sym, pfunc, *alias;
442f04c3 JP	211	struct list_head entry, tmp;
442f04c3 JP	212	int symbols_nr, i;
13810435	213	char *coldstr;
442f04c3 JP	214
	215	symtab = find_section_by_name(elf, ".symtab");
	216	if (!symtab) {
ce79b9cb JP	217	/*
	218	* A missing symbol table is actually possible if it's an empty
	219	* .o file. This can happen for thunk_64.o.
	220	*/
	221	return 0;
442f04c3 JP	222	}
	223
	224	symbols_nr = symtab->sh.sh_size / symtab->sh.sh_entsize;
	225
	226	for (i = 0; i < symbols_nr; i++) {
	227	sym = malloc(sizeof(*sym));
	228	if (!sym) {
	229	perror("malloc");
	230	return -1;
	231	}
	232	memset(sym, 0, sizeof(*sym));
09f30d83	233	alias = sym;
442f04c3 JP	234
	235	sym->idx = i;
	236
baa41469 JP	237	if (!gelf_getsym(symtab->data, i, &sym->sym)) {
baa41469 JP	238	WARN_ELF("gelf_getsym");
442f04c3 JP	239	goto err;
	240	}
	241
	242	sym->name = elf_strptr(elf->elf, symtab->sh.sh_link,
	243	sym->sym.st_name);
	244	if (!sym->name) {
baa41469	245	WARN_ELF("elf_strptr");
442f04c3 JP	246	goto err;
	247	}
	248
	249	sym->type = GELF_ST_TYPE(sym->sym.st_info);
	250	sym->bind = GELF_ST_BIND(sym->sym.st_info);
	251
	252	if (sym->sym.st_shndx > SHN_UNDEF &&
	253	sym->sym.st_shndx < SHN_LORESERVE) {
	254	sym->sec = find_section_by_index(elf,
	255	sym->sym.st_shndx);
	256	if (!sym->sec) {
	257	WARN("couldn't find section for symbol %s",
	258	sym->name);
	259	goto err;
	260	}
	261	if (sym->type == STT_SECTION) {
	262	sym->name = sym->sec->name;
	263	sym->sec->sym = sym;
	264	}
	265	} else
	266	sym->sec = find_section_by_index(elf, 0);
	267
	268	sym->offset = sym->sym.st_value;
	269	sym->len = sym->sym.st_size;
	270
	271	/* sorted insert into a per-section list */
a196e171 JP	272	entry = &sym->sec->symbol_list;
a196e171 JP	273	list_for_each_prev(tmp, &sym->sec->symbol_list) {
442f04c3 JP	274	struct symbol *s;
	275
	276	s = list_entry(tmp, struct symbol, list);
	277
	278	if (sym->offset > s->offset) {
	279	entry = tmp;
	280	break;
	281	}
	282
09f30d83	283	if (sym->offset == s->offset) {
e10cd8fe	284	if (sym->len && sym->len == s->len && alias == sym)
09f30d83 PZ	285	alias = s;
	286
	287	if (sym->len >= s->len) {
	288	entry = tmp;
	289	break;
	290	}
442f04c3 JP	291	}
442f04c3 JP	292	}
09f30d83	293	sym->alias = alias;
442f04c3	294	list_add(&sym->list, entry);
042ba73f	295	hash_add(sym->sec->symbol_hash, &sym->hash, sym->idx);
442f04c3 JP	296	}
442f04c3 JP	297
13810435 JP	298	/* Create parent/child links for any cold subfunctions */
	299	list_for_each_entry(sec, &elf->sections, list) {
	300	list_for_each_entry(sym, &sec->symbol_list, list) {
22566c16 AS	301	char pname[MAX_NAME_LEN + 1];
22566c16 AS	302	size_t pnamelen;
13810435 JP	303	if (sym->type != STT_FUNC)
	304	continue;
	305	sym->pfunc = sym->cfunc = sym;
bcb6fb5d	306	coldstr = strstr(sym->name, ".cold");
08b393d0 JP	307	if (!coldstr)
	308	continue;
	309
22566c16 AS	310	pnamelen = coldstr - sym->name;
	311	if (pnamelen > MAX_NAME_LEN) {
	312	WARN("%s(): parent function name exceeds maximum length of %d characters",
	313	sym->name, MAX_NAME_LEN);
	314	return -1;
	315	}
	316
	317	strncpy(pname, sym->name, pnamelen);
	318	pname[pnamelen] = '\0';
	319	pfunc = find_symbol_by_name(elf, pname);
08b393d0 JP	320
	321	if (!pfunc) {
	322	WARN("%s(): can't find parent function",
	323	sym->name);
0b9301fb	324	return -1;
08b393d0 JP	325	}
	326
	327	sym->pfunc = pfunc;
	328	pfunc->cfunc = sym;
	329
	330	/*
	331	* Unfortunately, -fnoreorder-functions puts the child
	332	* inside the parent. Remove the overlap so we can
	333	* have sane assumptions.
	334	*
	335	* Note that pfunc->len now no longer matches
	336	* pfunc->sym.st_size.
	337	*/
	338	if (sym->sec == pfunc->sec &&
	339	sym->offset >= pfunc->offset &&
	340	sym->offset + sym->len == pfunc->offset + pfunc->len) {
	341	pfunc->len -= sym->len;
13810435 JP	342	}
	343	}
	344	}
	345
442f04c3 JP	346	return 0;
	347
	348	err:
	349	free(sym);
	350	return -1;
	351	}
	352
	353	static int read_relas(struct elf *elf)
	354	{
	355	struct section *sec;
	356	struct rela *rela;
	357	int i;
	358	unsigned int symndx;
	359
	360	list_for_each_entry(sec, &elf->sections, list) {
	361	if (sec->sh.sh_type != SHT_RELA)
	362	continue;
	363
	364	sec->base = find_section_by_name(elf, sec->name + 5);
	365	if (!sec->base) {
	366	WARN("can't find base section for rela section %s",
	367	sec->name);
	368	return -1;
	369	}
	370
	371	sec->base->rela = sec;
	372
	373	for (i = 0; i < sec->sh.sh_size / sec->sh.sh_entsize; i++) {
	374	rela = malloc(sizeof(*rela));
	375	if (!rela) {
	376	perror("malloc");
	377	return -1;
	378	}
	379	memset(rela, 0, sizeof(*rela));
	380
baa41469 JP	381	if (!gelf_getrela(sec->data, i, &rela->rela)) {
baa41469 JP	382	WARN_ELF("gelf_getrela");
442f04c3 JP	383	return -1;
	384	}
	385
	386	rela->type = GELF_R_TYPE(rela->rela.r_info);
	387	rela->addend = rela->rela.r_addend;
	388	rela->offset = rela->rela.r_offset;
	389	symndx = GELF_R_SYM(rela->rela.r_info);
	390	rela->sym = find_symbol_by_index(elf, symndx);
e7c2bc37	391	rela->sec = sec;
442f04c3 JP	392	if (!rela->sym) {
	393	WARN("can't find rela entry symbol %d for %s",
	394	symndx, sec->name);
	395	return -1;
	396	}
042ba73f JP	397
	398	list_add_tail(&rela->list, &sec->rela_list);
	399	hash_add(sec->rela_hash, &rela->hash, rela->offset);
	400
442f04c3 JP	401	}
	402	}
	403
	404	return 0;
	405	}
	406
8e144797	407	struct elf elf_read(const char name, int flags)
442f04c3 JP	408	{
442f04c3 JP	409	struct elf *elf;
627fce14	410	Elf_Cmd cmd;
442f04c3 JP	411
	412	elf_version(EV_CURRENT);
	413
	414	elf = malloc(sizeof(*elf));
	415	if (!elf) {
	416	perror("malloc");
	417	return NULL;
	418	}
	419	memset(elf, 0, sizeof(*elf));
	420
	421	INIT_LIST_HEAD(&elf->sections);
	422
627fce14	423	elf->fd = open(name, flags);
442f04c3	424	if (elf->fd == -1) {
385d11b1 JP	425	fprintf(stderr, "objtool: Can't open '%s': %s\n",
385d11b1 JP	426	name, strerror(errno));
442f04c3 JP	427	goto err;
	428	}
	429
627fce14 JP	430	if ((flags & O_ACCMODE) == O_RDONLY)
	431	cmd = ELF_C_READ_MMAP;
	432	else if ((flags & O_ACCMODE) == O_RDWR)
	433	cmd = ELF_C_RDWR;
	434	else /* O_WRONLY */
	435	cmd = ELF_C_WRITE;
	436
	437	elf->elf = elf_begin(elf->fd, cmd, NULL);
442f04c3	438	if (!elf->elf) {
baa41469	439	WARN_ELF("elf_begin");
442f04c3 JP	440	goto err;
	441	}
	442
	443	if (!gelf_getehdr(elf->elf, &elf->ehdr)) {
baa41469	444	WARN_ELF("gelf_getehdr");
442f04c3 JP	445	goto err;
	446	}
	447
	448	if (read_sections(elf))
	449	goto err;
	450
	451	if (read_symbols(elf))
	452	goto err;
	453
	454	if (read_relas(elf))
	455	goto err;
	456
	457	return elf;
	458
	459	err:
	460	elf_close(elf);
	461	return NULL;
	462	}
	463
627fce14 JP	464	struct section elf_create_section(struct elf elf, const char *name,
	465	size_t entsize, int nr)
	466	{
	467	struct section sec, shstrtab;
	468	size_t size = entsize * nr;
3c3ea503	469	Elf_Scn *s;
627fce14 JP	470	Elf_Data *data;
	471
	472	sec = malloc(sizeof(*sec));
	473	if (!sec) {
	474	perror("malloc");
	475	return NULL;
	476	}
	477	memset(sec, 0, sizeof(*sec));
	478
	479	INIT_LIST_HEAD(&sec->symbol_list);
	480	INIT_LIST_HEAD(&sec->rela_list);
	481	hash_init(sec->rela_hash);
	482	hash_init(sec->symbol_hash);
	483
	484	list_add_tail(&sec->list, &elf->sections);
	485
	486	s = elf_newscn(elf->elf);
	487	if (!s) {
	488	WARN_ELF("elf_newscn");
	489	return NULL;
	490	}
	491
	492	sec->name = strdup(name);
	493	if (!sec->name) {
	494	perror("strdup");
	495	return NULL;
	496	}
	497
	498	sec->idx = elf_ndxscn(s);
	499	sec->len = size;
	500	sec->changed = true;
	501
	502	sec->data = elf_newdata(s);
	503	if (!sec->data) {
	504	WARN_ELF("elf_newdata");
	505	return NULL;
	506	}
	507
	508	sec->data->d_size = size;
	509	sec->data->d_align = 1;
	510
	511	if (size) {
	512	sec->data->d_buf = malloc(size);
	513	if (!sec->data->d_buf) {
	514	perror("malloc");
	515	return NULL;
	516	}
	517	memset(sec->data->d_buf, 0, size);
	518	}
	519
	520	if (!gelf_getshdr(s, &sec->sh)) {
	521	WARN_ELF("gelf_getshdr");
	522	return NULL;
	523	}
	524
	525	sec->sh.sh_size = size;
	526	sec->sh.sh_entsize = entsize;
	527	sec->sh.sh_type = SHT_PROGBITS;
	528	sec->sh.sh_addralign = 1;
	529	sec->sh.sh_flags = SHF_ALLOC;
	530
	531
6d77d3b4	532	/* Add section name to .shstrtab (or .strtab for Clang) */
627fce14	533	shstrtab = find_section_by_name(elf, ".shstrtab");
6d77d3b4 SS	534	if (!shstrtab)
6d77d3b4 SS	535	shstrtab = find_section_by_name(elf, ".strtab");
627fce14	536	if (!shstrtab) {
6d77d3b4	537	WARN("can't find .shstrtab or .strtab section");
627fce14 JP	538	return NULL;
	539	}
	540
	541	s = elf_getscn(elf->elf, shstrtab->idx);
	542	if (!s) {
	543	WARN_ELF("elf_getscn");
	544	return NULL;
	545	}
	546
	547	data = elf_newdata(s);
	548	if (!data) {
	549	WARN_ELF("elf_newdata");
	550	return NULL;
	551	}
	552
	553	data->d_buf = sec->name;
	554	data->d_size = strlen(name) + 1;
	555	data->d_align = 1;
	556
	557	sec->sh.sh_name = shstrtab->len;
	558
	559	shstrtab->len += strlen(name) + 1;
	560	shstrtab->changed = true;
	561
	562	return sec;
	563	}
	564
	565	struct section elf_create_rela_section(struct elf elf, struct section *base)
	566	{
	567	char *relaname;
	568	struct section *sec;
	569
	570	relaname = malloc(strlen(base->name) + strlen(".rela") + 1);
	571	if (!relaname) {
	572	perror("malloc");
	573	return NULL;
	574	}
	575	strcpy(relaname, ".rela");
	576	strcat(relaname, base->name);
	577
	578	sec = elf_create_section(elf, relaname, sizeof(GElf_Rela), 0);
0998b7a0	579	free(relaname);
627fce14 JP	580	if (!sec)
	581	return NULL;
	582
	583	base->rela = sec;
	584	sec->base = base;
	585
	586	sec->sh.sh_type = SHT_RELA;
	587	sec->sh.sh_addralign = 8;
	588	sec->sh.sh_link = find_section_by_name(elf, ".symtab")->idx;
	589	sec->sh.sh_info = base->idx;
	590	sec->sh.sh_flags = SHF_INFO_LINK;
	591
	592	return sec;
	593	}
	594
	595	int elf_rebuild_rela_section(struct section *sec)
	596	{
	597	struct rela *rela;
	598	int nr, idx = 0, size;
	599	GElf_Rela *relas;
	600
	601	nr = 0;
	602	list_for_each_entry(rela, &sec->rela_list, list)
	603	nr++;
	604
	605	size = nr * sizeof(*relas);
	606	relas = malloc(size);
	607	if (!relas) {
	608	perror("malloc");
	609	return -1;
	610	}
	611
	612	sec->data->d_buf = relas;
	613	sec->data->d_size = size;
	614
	615	sec->sh.sh_size = size;
	616
	617	idx = 0;
	618	list_for_each_entry(rela, &sec->rela_list, list) {
	619	relas[idx].r_offset = rela->offset;
	620	relas[idx].r_addend = rela->addend;
	621	relas[idx].r_info = GELF_R_INFO(rela->sym->idx, rela->type);
	622	idx++;
	623	}
	624
	625	return 0;
	626	}
	627
	628	int elf_write(struct elf *elf)
	629	{
	630	struct section *sec;
	631	Elf_Scn *s;
	632
97dab2ae	633	/* Update section headers for changed sections: */
627fce14 JP	634	list_for_each_entry(sec, &elf->sections, list) {
	635	if (sec->changed) {
	636	s = elf_getscn(elf->elf, sec->idx);
	637	if (!s) {
	638	WARN_ELF("elf_getscn");
	639	return -1;
	640	}
97dab2ae	641	if (!gelf_update_shdr(s, &sec->sh)) {
627fce14 JP	642	WARN_ELF("gelf_update_shdr");
	643	return -1;
	644	}
	645	}
	646	}
	647
97dab2ae JP	648	/* Make sure the new section header entries get updated properly. */
	649	elf_flagelf(elf->elf, ELF_C_SET, ELF_F_DIRTY);
	650
	651	/* Write all changes to the file. */
627fce14 JP	652	if (elf_update(elf->elf, ELF_C_WRITE) < 0) {
	653	WARN_ELF("elf_update");
	654	return -1;
	655	}
	656
	657	return 0;
	658	}
	659
442f04c3 JP	660	void elf_close(struct elf *elf)
	661	{
	662	struct section sec, tmpsec;
	663	struct symbol sym, tmpsym;
	664	struct rela rela, tmprela;
	665
baa41469 JP	666	if (elf->elf)
	667	elf_end(elf->elf);
	668
	669	if (elf->fd > 0)
	670	close(elf->fd);
	671
442f04c3	672	list_for_each_entry_safe(sec, tmpsec, &elf->sections, list) {
a196e171	673	list_for_each_entry_safe(sym, tmpsym, &sec->symbol_list, list) {
442f04c3	674	list_del(&sym->list);
042ba73f	675	hash_del(&sym->hash);
442f04c3 JP	676	free(sym);
442f04c3 JP	677	}
a196e171	678	list_for_each_entry_safe(rela, tmprela, &sec->rela_list, list) {
442f04c3	679	list_del(&rela->list);
042ba73f	680	hash_del(&rela->hash);
442f04c3 JP	681	free(rela);
	682	}
	683	list_del(&sec->list);
	684	free(sec);
	685	}
baa41469	686
442f04c3 JP	687	free(elf);
442f04c3 JP	688	}