// SPDX-License-Identifier: GPL-2.0-or-later

/*

* Copyright (C) 2015-2017 Josh Poimboeuf <jpoimboe@redhat.com>

*/

#include <string.h>

#include <stdlib.h>

#include <inttypes.h>

#include <sys/mman.h>

#include <arch/elf.h>

#include <objtool/builtin.h>

#include <objtool/cfi.h>

#include <objtool/arch.h>

#include <objtool/check.h>

#include <objtool/special.h>

#include <objtool/warn.h>

#include <objtool/endianness.h>

#include <linux/objtool_types.h>

#include <linux/hashtable.h>

#include <linux/kernel.h>

#include <linux/static_call_types.h>

struct alternative {

struct alternative *next;

struct instruction *insn;

bool skip_orig;

};

static unsigned long nr_cfi, nr_cfi_reused, nr_cfi_cache;

static struct cfi_init_state initial_func_cfi;

static struct cfi_state init_cfi;

static struct cfi_state func_cfi;

struct instruction *find_insn(struct objtool_file *file,

struct section *sec, unsigned long offset)

{

struct instruction *insn;

hash_for_each_possible(file->insn_hash, insn, hash, sec_offset_hash(sec, offset)) {

if (insn->sec == sec && insn->offset == offset)

return insn;

}

return NULL;

}

struct instruction *next_insn_same_sec(struct objtool_file *file,

struct instruction *insn)

{

if (insn->idx == INSN_CHUNK_MAX)

return find_insn(file, insn->sec, insn->offset + insn->len);

insn++;

if (!insn->len)

return NULL;

return insn;

}

static struct instruction *next_insn_same_func(struct objtool_file *file,

struct instruction *insn)

{

struct instruction *next = next_insn_same_sec(file, insn);

struct symbol *func = insn_func(insn);

if (!func)

return NULL;

if (next && insn_func(next) == func)

return next;

/* Check if we're already in the subfunction: */

if (func == func->cfunc)

return NULL;

/* Move to the subfunction: */

return find_insn(file, func->cfunc->sec, func->cfunc->offset);

}

static struct instruction *prev_insn_same_sec(struct objtool_file *file,

struct instruction *insn)

{

if (insn->idx == 0) {

if (insn->prev_len)

return find_insn(file, insn->sec, insn->offset - insn->prev_len);

return NULL;

}

return insn - 1;

}

static struct instruction *prev_insn_same_sym(struct objtool_file *file,

struct instruction *insn)

{

struct instruction *prev = prev_insn_same_sec(file, insn);

if (prev && insn_func(prev) == insn_func(insn))

return prev;

return NULL;

}

#define for_each_insn(file, insn) \

for (struct section *__sec, *__fake = (struct section *)1; \

__fake; __fake = NULL) \

for_each_sec(file, __sec) \

sec_for_each_insn(file, __sec, insn)

#define func_for_each_insn(file, func, insn) \

for (insn = find_insn(file, func->sec, func->offset); \

insn; \

insn = next_insn_same_func(file, insn))

#define sym_for_each_insn(file, sym, insn) \

for (insn = find_insn(file, sym->sec, sym->offset); \

insn && insn->offset < sym->offset + sym->len; \

insn = next_insn_same_sec(file, insn))

#define sym_for_each_insn_continue_reverse(file, sym, insn) \

for (insn = prev_insn_same_sec(file, insn); \

insn && insn->offset >= sym->offset; \

insn = prev_insn_same_sec(file, insn))

#define sec_for_each_insn_from(file, insn) \

for (; insn; insn = next_insn_same_sec(file, insn))

#define sec_for_each_insn_continue(file, insn) \

for (insn = next_insn_same_sec(file, insn); insn; \

insn = next_insn_same_sec(file, insn))

static inline struct symbol *insn_call_dest(struct instruction *insn)

{

if (insn->type == INSN_JUMP_DYNAMIC ||

insn->type == INSN_CALL_DYNAMIC)

return NULL;

return insn->_call_dest;

}

static inline struct reloc *insn_jump_table(struct instruction *insn)

{

if (insn->type == INSN_JUMP_DYNAMIC ||

insn->type == INSN_CALL_DYNAMIC)

return insn->_jump_table;

return NULL;

}

static bool is_jump_table_jump(struct instruction *insn)

{

struct alt_group *alt_group = insn->alt_group;

if (insn_jump_table(insn))

return true;

/* Retpoline alternative for a jump table? */

return alt_group && alt_group->orig_group &&

insn_jump_table(alt_group->orig_group->first_insn);

}

static bool is_sibling_call(struct instruction *insn)

{

/*

* Assume only STT_FUNC calls have jump-tables.

*/

if (insn_func(insn)) {

/* An indirect jump is either a sibling call or a jump to a table. */

if (insn->type == INSN_JUMP_DYNAMIC)

return !is_jump_table_jump(insn);

}

/* add_jump_destinations() sets insn_call_dest(insn) for sibling calls. */

return (is_static_jump(insn) && insn_call_dest(insn));

}

/*

* This checks to see if the given function is a "noreturn" function.

*

* For global functions which are outside the scope of this object file, we

* have to keep a manual list of them.

*

* For local functions, we have to detect them manually by simply looking for

* the lack of a return instruction.

*/

static bool __dead_end_function(struct objtool_file *file, struct symbol *func,

int recursion)

{

int i;

struct instruction *insn;

bool empty = true;

/*

* Unfortunately these have to be hard coded because the noreturn

* attribute isn't provided in ELF data. Keep 'em sorted.

*/

static const char * const global_noreturns[] = {

"__invalid_creds",

"__module_put_and_kthread_exit",

"__reiserfs_panic",

"__stack_chk_fail",

"__ubsan_handle_builtin_unreachable",

"arch_call_rest_init",

"arch_cpu_idle_dead",

"btrfs_assertfail",

"cpu_bringup_and_idle",

"cpu_startup_entry",

"do_exit",

"do_group_exit",

"do_task_dead",

"ex_handler_msr_mce",

"fortify_panic",

"hlt_play_dead",

"hv_ghcb_terminate",

"kthread_complete_and_exit",

"kthread_exit",

"kunit_try_catch_throw",

"lbug_with_loc",

"machine_real_restart",

"make_task_dead",

"mpt_halt_firmware",

"nmi_panic_self_stop",

"panic",

"panic_smp_self_stop",

"rest_init",

"resume_play_dead",

"rewind_stack_and_make_dead",

"sev_es_terminate",

"snp_abort",

"start_kernel",

"stop_this_cpu",

"usercopy_abort",

"x86_64_start_kernel",

"x86_64_start_reservations",

"xen_cpu_bringup_again",

"xen_start_kernel",

};

if (!func)

return false;

if (func->bind == STB_GLOBAL || func->bind == STB_WEAK)

for (i = 0; i < ARRAY_SIZE(global_noreturns); i++)

if (!strcmp(func->name, global_noreturns[i]))

return true;

if (func->bind == STB_WEAK)

return false;

if (!func->len)

return false;

insn = find_insn(file, func->sec, func->offset);

if (!insn || !insn_func(insn))

return false;

func_for_each_insn(file, func, insn) {

empty = false;

if (insn->type == INSN_RETURN)

return false;

}

if (empty)

return false;

/*

* A function can have a sibling call instead of a return. In that

* case, the function's dead-end status depends on whether the target

* of the sibling call returns.

*/

func_for_each_insn(file, func, insn) {

if (is_sibling_call(insn)) {

struct instruction *dest = insn->jump_dest;

if (!dest)

/* sibling call to another file */

return false;

/* local sibling call */

if (recursion == 5) {

/*

* Infinite recursion: two functions have

* sibling calls to each other. This is a very

* rare case. It means they aren't dead ends.

*/

return false;

}

return __dead_end_function(file, insn_func(dest), recursion+1);

}

}

return true;

}

static bool dead_end_function(struct objtool_file *file, struct symbol *func)

{

return __dead_end_function(file, func, 0);

}

static void init_cfi_state(struct cfi_state *cfi)

{

int i;

for (i = 0; i < CFI_NUM_REGS; i++) {

cfi->regs[i].base = CFI_UNDEFINED;

cfi->vals[i].base = CFI_UNDEFINED;

}

cfi->cfa.base = CFI_UNDEFINED;

cfi->drap_reg = CFI_UNDEFINED;

cfi->drap_offset = -1;

}

static void init_insn_state(struct objtool_file *file, struct insn_state *state,

struct section *sec)

{

memset(state, 0, sizeof(*state));

init_cfi_state(&state->cfi);

/*

* We need the full vmlinux for noinstr validation, otherwise we can

* not correctly determine insn_call_dest(insn)->sec (external symbols

* do not have a section).

*/

if (opts.link && opts.noinstr && sec)

state->noinstr = sec->noinstr;

}

static struct cfi_state *cfi_alloc(void)

{

struct cfi_state *cfi = calloc(sizeof(struct cfi_state), 1);

if (!cfi) {

WARN("calloc failed");

exit(1);

}

nr_cfi++;

return cfi;

}

static int cfi_bits;

static struct hlist_head *cfi_hash;

static inline bool cficmp(struct cfi_state *cfi1, struct cfi_state *cfi2)

{

return memcmp((void *)cfi1 + sizeof(cfi1->hash),

(void *)cfi2 + sizeof(cfi2->hash),

sizeof(struct cfi_state) - sizeof(struct hlist_node));

}

static inline u32 cfi_key(struct cfi_state *cfi)

{

return jhash((void *)cfi + sizeof(cfi->hash),

sizeof(*cfi) - sizeof(cfi->hash), 0);

}

static struct cfi_state *cfi_hash_find_or_add(struct cfi_state *cfi)

{

struct hlist_head *head = &cfi_hash[hash_min(cfi_key(cfi), cfi_bits)];

struct cfi_state *obj;

hlist_for_each_entry(obj, head, hash) {

if (!cficmp(cfi, obj)) {

nr_cfi_cache++;

return obj;

}

}

obj = cfi_alloc();

*obj = *cfi;

hlist_add_head(&obj->hash, head);

return obj;

}

static void cfi_hash_add(struct cfi_state *cfi)

{

struct hlist_head *head = &cfi_hash[hash_min(cfi_key(cfi), cfi_bits)];

hlist_add_head(&cfi->hash, head);

}

static void *cfi_hash_alloc(unsigned long size)

{

cfi_bits = max(10, ilog2(size));

cfi_hash = mmap(NULL, sizeof(struct hlist_head) << cfi_bits,

PROT_READ|PROT_WRITE,

MAP_PRIVATE|MAP_ANON, -1, 0);

if (cfi_hash == (void *)-1L) {

WARN("mmap fail cfi_hash");

cfi_hash = NULL;

} else if (opts.stats) {

printf("cfi_bits: %d\n", cfi_bits);

}

return cfi_hash;

}

static unsigned long nr_insns;

static unsigned long nr_insns_visited;

/*

* Call the arch-specific instruction decoder for all the instructions and add

* them to the global instruction list.

*/

static int decode_instructions(struct objtool_file *file)

{

struct section *sec;

struct symbol *func;

unsigned long offset;

struct instruction *insn;

int ret;

for_each_sec(file, sec) {

struct instruction *insns = NULL;

u8 prev_len = 0;

u8 idx = 0;

if (!(sec->sh.sh_flags & SHF_EXECINSTR))

continue;

if (strcmp(sec->name, ".altinstr_replacement") &&

strcmp(sec->name, ".altinstr_aux") &&

strncmp(sec->name, ".discard.", 9))

sec->text = true;

if (!strcmp(sec->name, ".noinstr.text") ||

!strcmp(sec->name, ".entry.text") ||

!strcmp(sec->name, ".cpuidle.text") ||

!strncmp(sec->name, ".text.__x86.", 12))

sec->noinstr = true;

/*

* .init.text code is ran before userspace and thus doesn't

* strictly need retpolines, except for modules which are

* loaded late, they very much do need retpoline in their

* .init.text

*/

if (!strcmp(sec->name, ".init.text") && !opts.module)

sec->init = true;

for (offset = 0; offset < sec->sh.sh_size; offset += insn->len) {

if (!insns || idx == INSN_CHUNK_MAX) {

insns = calloc(sizeof(*insn), INSN_CHUNK_SIZE);

if (!insns) {

WARN("malloc failed");

return -1;

}

idx = 0;

} else {

idx++;

}

insn = &insns[idx];

insn->idx = idx;

INIT_LIST_HEAD(&insn->call_node);

insn->sec = sec;

insn->offset = offset;

insn->prev_len = prev_len;

ret = arch_decode_instruction(file, sec, offset,

sec->sh.sh_size - offset,

insn);

if (ret)

return ret;

prev_len = insn->len;

/*

* By default, "ud2" is a dead end unless otherwise

* annotated, because GCC 7 inserts it for certain

* divide-by-zero cases.

*/

if (insn->type == INSN_BUG)

insn->dead_end = true;

hash_add(file->insn_hash, &insn->hash, sec_offset_hash(sec, insn->offset));

nr_insns++;

}

// printf("%s: last chunk used: %d\n", sec->name, (int)idx);

sec_for_each_sym(sec, func) {

if (func->type != STT_NOTYPE && func->type != STT_FUNC)

continue;

if (func->offset == sec->sh.sh_size) {

/* Heuristic: likely an "end" symbol */

if (func->type == STT_NOTYPE)

continue;

WARN("%s(): STT_FUNC at end of section",

func->name);

return -1;

}

if (func->return_thunk || func->alias != func)

continue;

if (!find_insn(file, sec, func->offset)) {

WARN("%s(): can't find starting instruction",

func->name);

return -1;

}

sym_for_each_insn(file, func, insn) {

insn->sym = func;

if (func->type == STT_FUNC &&

insn->type == INSN_ENDBR &&

list_empty(&insn->call_node)) {

if (insn->offset == func->offset) {

list_add_tail(&insn->call_node, &file->endbr_list);

file->nr_endbr++;

} else {

file->nr_endbr_int++;

}

}

}

}

}

if (opts.stats)

printf("nr_insns: %lu\n", nr_insns);

return 0;

}

/*

* Read the pv_ops[] .data table to find the static initialized values.

*/

static int add_pv_ops(struct objtool_file *file, const char *symname)

{

struct symbol *sym, *func;

unsigned long off, end;

struct reloc *rel;

int idx;

sym = find_symbol_by_name(file->elf, symname);

if (!sym)

return 0;

off = sym->offset;

end = off + sym->len;

for (;;) {

rel = find_reloc_by_dest_range(file->elf, sym->sec, off, end - off);

if (!rel)

break;

func = rel->sym;

if (func->type == STT_SECTION)

func = find_symbol_by_offset(rel->sym->sec, rel->addend);

idx = (rel->offset - sym->offset) / sizeof(unsigned long);

objtool_pv_add(file, idx, func);

off = rel->offset + 1;

if (off > end)

break;

}

return 0;

}

/*

* Allocate and initialize file->pv_ops[].

*/

static int init_pv_ops(struct objtool_file *file)

{

static const char *pv_ops_tables[] = {

"pv_ops",

"xen_cpu_ops",

"xen_irq_ops",

"xen_mmu_ops",

NULL,

};

const char *pv_ops;

struct symbol *sym;

int idx, nr;

if (!opts.noinstr)

return 0;

file->pv_ops = NULL;

sym = find_symbol_by_name(file->elf, "pv_ops");

if (!sym)

return 0;

nr = sym->len / sizeof(unsigned long);

file->pv_ops = calloc(sizeof(struct pv_state), nr);

if (!file->pv_ops)

return -1;

for (idx = 0; idx < nr; idx++)

INIT_LIST_HEAD(&file->pv_ops[idx].targets);

for (idx = 0; (pv_ops = pv_ops_tables[idx]); idx++)

add_pv_ops(file, pv_ops);

return 0;

}

static struct instruction *find_last_insn(struct objtool_file *file,

struct section *sec)

{

struct instruction *insn = NULL;

unsigned int offset;

unsigned int end = (sec->sh.sh_size > 10) ? sec->sh.sh_size - 10 : 0;

for (offset = sec->sh.sh_size - 1; offset >= end && !insn; offset--)

insn = find_insn(file, sec, offset);

return insn;

}

/*

* Mark "ud2" instructions and manually annotated dead ends.

*/

static int add_dead_ends(struct objtool_file *file)

{

struct section *sec;

struct reloc *reloc;

struct instruction *insn;

/*

* Check for manually annotated dead ends.

*/

sec = find_section_by_name(file->elf, ".rela.discard.unreachable");

if (!sec)

goto reachable;

list_for_each_entry(reloc, &sec->reloc_list, list) {

if (reloc->sym->type != STT_SECTION) {

WARN("unexpected relocation symbol type in %s", sec->name);

return -1;

}

insn = find_insn(file, reloc->sym->sec, reloc->addend);

if (insn)

insn = prev_insn_same_sec(file, insn);

else if (reloc->addend == reloc->sym->sec->sh.sh_size) {

insn = find_last_insn(file, reloc->sym->sec);

if (!insn) {

WARN("can't find unreachable insn at %s+0x%" PRIx64,

reloc->sym->sec->name, reloc->addend);

return -1;

}

} else {

WARN("can't find unreachable insn at %s+0x%" PRIx64,

reloc->sym->sec->name, reloc->addend);

return -1;

}

insn->dead_end = true;

}

reachable:

/*

* These manually annotated reachable checks are needed for GCC 4.4,

* where the Linux unreachable() macro isn't supported. In that case

* GCC doesn't know the "ud2" is fatal, so it generates code as if it's

* not a dead end.

*/

sec = find_section_by_name(file->elf, ".rela.discard.reachable");

if (!sec)

return 0;

list_for_each_entry(reloc, &sec->reloc_list, list) {

if (reloc->sym->type != STT_SECTION) {

WARN("unexpected relocation symbol type in %s", sec->name);

return -1;

}

insn = find_insn(file, reloc->sym->sec, reloc->addend);

if (insn)

insn = prev_insn_same_sec(file, insn);

else if (reloc->addend == reloc->sym->sec->sh.sh_size) {

insn = find_last_insn(file, reloc->sym->sec);

if (!insn) {

WARN("can't find reachable insn at %s+0x%" PRIx64,

reloc->sym->sec->name, reloc->addend);

return -1;

}

} else {

WARN("can't find reachable insn at %s+0x%" PRIx64,

reloc->sym->sec->name, reloc->addend);

return -1;

}

insn->dead_end = false;

}

return 0;

}

static int create_static_call_sections(struct objtool_file *file)

{

struct section *sec;

struct static_call_site *site;

struct instruction *insn;

struct symbol *key_sym;

char *key_name, *tmp;

int idx;

sec = find_section_by_name(file->elf, ".static_call_sites");

if (sec) {

INIT_LIST_HEAD(&file->static_call_list);

WARN("file already has .static_call_sites section, skipping");

return 0;

}

if (list_empty(&file->static_call_list))

return 0;

idx = 0;

list_for_each_entry(insn, &file->static_call_list, call_node)

idx++;

sec = elf_create_section(file->elf, ".static_call_sites", SHF_WRITE,

sizeof(struct static_call_site), idx);

if (!sec)

return -1;

idx = 0;

list_for_each_entry(insn, &file->static_call_list, call_node) {

site = (struct static_call_site *)sec->data->d_buf + idx;

memset(site, 0, sizeof(struct static_call_site));

/* populate reloc for 'addr' */

if (elf_add_reloc_to_insn(file->elf, sec,

idx * sizeof(struct static_call_site),

R_X86_64_PC32,

insn->sec, insn->offset))

return -1;

/* find key symbol */

key_name = strdup(insn_call_dest(insn)->name);

if (!key_name) {

perror("strdup");

return -1;

}

if (strncmp(key_name, STATIC_CALL_TRAMP_PREFIX_STR,

STATIC_CALL_TRAMP_PREFIX_LEN)) {

WARN("static_call: trampoline name malformed: %s", key_name);

free(key_name);

return -1;

}

tmp = key_name + STATIC_CALL_TRAMP_PREFIX_LEN - STATIC_CALL_KEY_PREFIX_LEN;

memcpy(tmp, STATIC_CALL_KEY_PREFIX_STR, STATIC_CALL_KEY_PREFIX_LEN);

key_sym = find_symbol_by_name(file->elf, tmp);

if (!key_sym) {

if (!opts.module) {

WARN("static_call: can't find static_call_key symbol: %s", tmp);

free(key_name);

return -1;

}

/*

* For modules(), the key might not be exported, which

* means the module can make static calls but isn't

* allowed to change them.

*

* In that case we temporarily set the key to be the

* trampoline address. This is fixed up in

* static_call_add_module().

*/

key_sym = insn_call_dest(insn);

}

free(key_name);

/* populate reloc for 'key' */

if (elf_add_reloc(file->elf, sec,

idx * sizeof(struct static_call_site) + 4,

R_X86_64_PC32, key_sym,

is_sibling_call(insn) * STATIC_CALL_SITE_TAIL))

return -1;

idx++;

}

return 0;

}

static int create_retpoline_sites_sections(struct objtool_file *file)

{

struct instruction *insn;

struct section *sec;

int idx;

sec = find_section_by_name(file->elf, ".retpoline_sites");

if (sec) {

WARN("file already has .retpoline_sites, skipping");

return 0;

}

idx = 0;

list_for_each_entry(insn, &file->retpoline_call_list, call_node)

idx++;

if (!idx)

return 0;

sec = elf_create_section(file->elf, ".retpoline_sites", 0,

sizeof(int), idx);

if (!sec) {

WARN("elf_create_section: .retpoline_sites");

return -1;

}

idx = 0;

list_for_each_entry(insn, &file->retpoline_call_list, call_node) {

int *site = (int *)sec->data->d_buf + idx;

*site = 0;

if (elf_add_reloc_to_insn(file->elf, sec,

idx * sizeof(int),

R_X86_64_PC32,

insn->sec, insn->offset)) {

WARN("elf_add_reloc_to_insn: .retpoline_sites");

return -1;

}

idx++;

}

return 0;

}

static int create_return_sites_sections(struct objtool_file *file)

{

struct instruction *insn;

struct section *sec;

int idx;

sec = find_section_by_name(file->elf, ".return_sites");

if (sec) {

WARN("file already has .return_sites, skipping");

return 0;

}

idx = 0;

list_for_each_entry(insn, &file->return_thunk_list, call_node)

idx++;

if (!idx)

return 0;

sec = elf_create_section(file->elf, ".return_sites", 0,

sizeof(int), idx);

if (!sec) {

WARN("elf_create_section: .return_sites");

return -1;

}

idx = 0;

list_for_each_entry(insn, &file->return_thunk_list, call_node) {

int *site = (int *)sec->data->d_buf + idx;

*site = 0;

if (elf_add_reloc_to_insn(file->elf, sec,

idx * sizeof(int),

R_X86_64_PC32,

insn->sec, insn->offset)) {

WARN("elf_add_reloc_to_insn: .return_sites");

return -1;

}

idx++;

}

return 0;

}

static int create_ibt_endbr_seal_sections(struct objtool_file *file)

{

struct instruction *insn;

struct section *sec;

int idx;

sec = find_section_by_name(file->elf, ".ibt_endbr_seal");

if (sec) {

WARN("file already has .ibt_endbr_seal, skipping");

return 0;

}

idx = 0;

list_for_each_entry(insn, &file->endbr_list, call_node)

idx++;

if (opts.stats) {

printf("ibt: ENDBR at function start: %d\n", file->nr_endbr);

printf("ibt: ENDBR inside functions: %d\n", file->nr_endbr_int);

printf("ibt: superfluous ENDBR: %d\n", idx);

}

if (!idx)

return 0;

sec = elf_create_section(file->elf, ".ibt_endbr_seal", 0,

sizeof(int), idx);

if (!sec) {

WARN("elf_create_section: .ibt_endbr_seal");

return -1;

}

idx = 0;

list_for_each_entry(insn, &file->endbr_list, call_node) {

int *site = (int *)sec->data->d_buf + idx;

struct symbol *sym = insn->sym;

*site = 0;

if (opts.module && sym && sym->type == STT_FUNC &&

insn->offset == sym->offset &&

(!strcmp(sym->name, "init_module") ||

!strcmp(sym->name, "cleanup_module")))

WARN("%s(): not an indirect call target", sym->name);

if (elf_add_reloc_to_insn(file->elf, sec,

idx * sizeof(int),

R_X86_64_PC32,

insn->sec, insn->offset)) {

WARN("elf_add_reloc_to_insn: .ibt_endbr_seal");

return -1;

}

idx++;

}

return 0;

}

static int create_cfi_sections(struct objtool_file *file)

{

struct section *sec;

struct symbol *sym;

unsigned int *loc;

int idx;

sec = find_section_by_name(file->elf, ".cfi_sites");

if (sec) {

INIT_LIST_HEAD(&file->call_list);

WARN("file already has .cfi_sites section, skipping");

return 0;

}

idx = 0;

for_each_sym(file, sym) {

if (sym->type != STT_FUNC)

continue;

if (strncmp(sym->name, "__cfi_", 6))

continue;

idx++;

}

sec = elf_create_section(file->elf, ".cfi_sites", 0, sizeof(unsigned int), idx);

if (!sec)

return -1;

idx = 0;

for_each_sym(file, sym) {

if (sym->type != STT_FUNC)

continue;

if (strncmp(sym->name, "__cfi_", 6))

continue;

loc = (unsigned int *)sec->data->d_buf + idx;

memset(loc, 0, sizeof(unsigned int));

if (elf_add_reloc_to_insn(file->elf, sec,

idx * sizeof(unsigned int),

R_X86_64_PC32,

sym->sec, sym->offset))

return -1;

idx++;

}

return 0;

}

static int create_mcount_loc_sections(struct objtool_file *file)

{

int addrsize = elf_class_addrsize(file->elf);

struct instruction *insn;

struct section *sec;

int idx;

sec = find_section_by_name(file->elf, "__mcount_loc");

if (sec) {

INIT_LIST_HEAD(&file->mcount_loc_list);

WARN("file already has __mcount_loc section, skipping");

return 0;