/*

 * create-diff-object.c

 *

 * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>

 * Copyright (C) 2013-2014 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, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA,

 * 02110-1301, USA.

 */

/*

 * This file contains the heart of the ELF object differencing engine.

 *

 * The tool takes two ELF objects from two versions of the same source

 * file; a "base" object and a "patched" object.  These object need to have

 * been compiled with the -ffunction-sections and -fdata-sections GCC options.

 *

 * The tool compares the objects at a section level to determine what

 * sections have changed.  Once a list of changed sections has been generated,

 * various rules are applied to determine any object local sections that

 * are dependencies of the changed section and also need to be included in

 * the output object.

 */

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <error.h>

#include <gelf.h>

#include <argp.h>

#include <libgen.h>

#include <unistd.h>

#include "list.h"

#include "lookup.h"

#include "asm/insn.h"

#include "kpatch-patch.h"

#include "kpatch-elf.h"

#include "kpatch-intermediate.h"

#include "kpatch.h"

#define DIFF_FATAL(format, ...) \

({ \

	fprintf(stderr, "ERROR: %s: " format "\n", childobj, ##__VA_ARGS__); \

	error(EXIT_STATUS_DIFF_FATAL, 0, "unreconcilable difference"); \

})

#ifdef __powerpc64__

#define ABSOLUTE_RELA_TYPE R_PPC64_ADDR64

#else

#define ABSOLUTE_RELA_TYPE R_X86_64_64

#endif

char *childobj;

enum subsection {

	SUBSECTION_NORMAL,

	SUBSECTION_HOT,

	SUBSECTION_UNLIKELY

};

enum loglevel loglevel = NORMAL;

bool KLP_ARCH;

/*******************

 * Data structures

 * ****************/

struct special_section {

	char *name;

	int (*group_size)(struct kpatch_elf *kelf, int offset);

};

/*************

 * Functions

 * **********/

static int is_bundleable(struct symbol *sym)

{

	if (sym->type == STT_FUNC &&

	    !strncmp(sym->sec->name, ".text.",6) &&

	    !strcmp(sym->sec->name + 6, sym->name))

		return 1;

	if (sym->type == STT_FUNC &&

	    !strncmp(sym->sec->name, ".text.unlikely.",15) &&

	    (!strcmp(sym->sec->name + 15, sym->name) ||

			 (strstr(sym->name, ".cold.") &&

			  !strncmp(sym->sec->name + 15, sym->name, strlen(sym->sec->name) - 15))))

		return 1;

	if (sym->type == STT_FUNC &&

	    !strncmp(sym->sec->name, ".text.hot.",10) &&

	    !strcmp(sym->sec->name + 10, sym->name))

		return 1;

	if (sym->type == STT_OBJECT &&

	   !strncmp(sym->sec->name, ".data.",6) &&

	   !strcmp(sym->sec->name + 6, sym->name))

		return 1;

	if (sym->type == STT_OBJECT &&

	    !strncmp(sym->sec->name, ".data.rel.", 10) &&

	    !strcmp(sym->sec->name + 10, sym->name))

		return 1;

	if (sym->type == STT_OBJECT &&

	    !strncmp(sym->sec->name, ".data.rel.ro.", 13) &&

	    !strcmp(sym->sec->name + 13, sym->name))

		return 1;

	if (sym->type == STT_OBJECT &&

	   !strncmp(sym->sec->name, ".rodata.",8) &&

	   !strcmp(sym->sec->name + 8, sym->name))

		return 1;

	if (sym->type == STT_OBJECT &&

	   !strncmp(sym->sec->name, ".bss.",5) &&

	   !strcmp(sym->sec->name + 5, sym->name))

		return 1;

	return 0;

}

#ifdef __powerpc64__

/* Symbol st_others value for powerpc */

#define STO_PPC64_LOCAL_BIT     5

#define STO_PPC64_LOCAL_MASK    (7 << STO_PPC64_LOCAL_BIT)

#define PPC64_LOCAL_ENTRY_OFFSET(other)                                 \

	        (((1 << (((other) & STO_PPC64_LOCAL_MASK) >> STO_PPC64_LOCAL_BIT)) >> 2) << 2)

/*

 * On ppc64le, the function prologue generated by GCC 6+ has the sequence:

 *

 *	.globl my_func

 *	.type my_func, @function

 *	.quad .TOC.-my_func

 * my_func:

 *	.reloc ., R_PPC64_ENTRY ; optional

 *	ld r2,-8(r12)

 *	add r2,r2,r12

 *	.localentry my_func, .-my_func

 *

 * my_func is the global entry point, which, when called, sets up the TOC.

 * .localentry is the local entry point, for calls to the function from within

 * the object file.  The local entry point is 8 bytes after the global entry

 * point.

 */

static int is_gcc6_localentry_bundled_sym(struct symbol *sym)

{

	return ((PPC64_LOCAL_ENTRY_OFFSET(sym->sym.st_other) != 0) &&

		sym->sym.st_value == 8);

}

#else

static int is_gcc6_localentry_bundled_sym(struct symbol *sym)

{

	return 0;

}

#endif

/*

 * On ppc64le, when a function references data, it does so indirectly, via the

 * .toc section.  So there are *two* levels of relas:

 *

 *   1) the original function rela, referring to the .toc section; and

 *

 *   2) the .toc section rela, referring to the data needed by the function.

 *

 * For example:

 *

 *   Relocation section '.rela.text.netlink_release' at offset 0xcadf0 contains 44 entries:

 *   ...

 *   0000000000000398  0000007300000032 R_PPC64_TOC16_HA    0000000000000000 .toc + 138

 *   00000000000003a0  0000007300000040 R_PPC64_TOC16_LO_DS 0000000000000000 .toc + 138

 *

 *   Relocation section '.rela.toc' at offset 0xcc6b0 contains 46 entries:

 *   ...

 *   0000000000000138  0000002a00000026 R_PPC64_ADDR64      0000000000000000 .text.deferred_put_nlk_sk + 8

 *

 * The below function takes the "first level" rela as input, and, if it refers

 * to .toc, returns the "second level" rela, which is the one that refers to

 * the actual data symbol.

 *

 * In some rare cases, a .toc entry has constant data, and thus has no

 * corresponding rela.  In that case, NULL is returned.

 */

static struct rela *toc_rela(const struct rela *rela)

{

	if (rela->type != R_PPC64_TOC16_HA &&

	    rela->type != R_PPC64_TOC16_LO_DS)

		return (struct rela *)rela;

	/* Only constants in toc */

	if (!rela->sym->sec->rela)

		return NULL;

	/* Will return NULL for .toc constant entries */

	return find_rela_by_offset(rela->sym->sec->rela,

				   (unsigned int)rela->addend);

}

/*

 * When compiling with -ffunction-sections and -fdata-sections, almost every

 * symbol gets its own dedicated section.  We call such symbols "bundled"

 * symbols.  They're indicated by "sym->sec->sym == sym".

 */

static void kpatch_bundle_symbols(struct kpatch_elf *kelf)

{

	struct symbol *sym;

	list_for_each_entry(sym, &kelf->symbols, list) {

		if (is_bundleable(sym)) {

			if (sym->sym.st_value != 0 &&

			    !is_gcc6_localentry_bundled_sym(sym)) {

				ERROR("symbol %s at offset %lu within section %s, expected 0",

				      sym->name, sym->sym.st_value,

				      sym->sec->name);

			}

			sym->sec->sym = sym;

		}

	}

}

static struct symbol *kpatch_lookup_parent(struct kpatch_elf *kelf,

					   const char *symname,

					   const char *child_suffix)

{

	struct symbol *parent;

	char *pname;

	pname = strndup(symname, child_suffix - symname);

	if (!pname)

		ERROR("strndup");

	parent = find_symbol_by_name(&kelf->symbols, pname);

	free(pname);

	return parent;

}

/*

 * During optimization gcc may move unlikely execution branches into *.cold

 * subfunctions. Some functions can also be split into multiple *.part

 * functions.

 * kpatch_detect_child_functions detects such subfunctions and

 * crossreferences them with their parent functions through parent/child

 * pointers.

 */

static void kpatch_detect_child_functions(struct kpatch_elf *kelf)

{

	struct symbol *sym;

	list_for_each_entry(sym, &kelf->symbols, list) {

		char *childstr;

		if (sym->type != STT_FUNC)

			continue;

		childstr = strstr(sym->name, ".cold.");

		if (childstr) {

			sym->parent = kpatch_lookup_parent(kelf, sym->name,

							   childstr);

			if (!sym->parent)

				ERROR("failed to find parent function for %s",

				      sym->name);

		} else {

			childstr = strstr(sym->name, ".part.");

			if (!childstr)

				continue;

			sym->parent = kpatch_lookup_parent(kelf, sym->name,

							   childstr);

		}

		if (sym->parent)

			list_add_tail(&sym->subfunction_node, &sym->parent->children);

	}

}

static bool is_dynamic_debug_symbol(struct symbol *sym)

{

	if (sym->type == STT_OBJECT && !strcmp(sym->sec->name, "__verbose"))

		return true;

	if (sym->type == STT_SECTION && !strcmp(sym->name, "__verbose"))

		return true;

	return false;

}

/*

 * This function detects whether the given symbol is a "special" static local

 * variable (for lack of a better term).

 *

 * Special static local variables should never be correlated and should always

 * be included if they are referenced by an included function.

 */

static int is_special_static(struct symbol *sym)

{

	static char *prefixes[] = {

		"__key.",

		"__warned.",

		"__func__.",

		"__FUNCTION__.",

		"_rs.",

		"CSWTCH.",

		NULL,

	};

	char **prefix;

	if (!sym)

		return 0;

	/* pr_debug() uses static local variables in the __verbose section */

	if (is_dynamic_debug_symbol(sym))

		return 1;

	if (sym->type == STT_SECTION) {

		/* make sure section is bundled */

		if (!sym->sec->sym)

			return 0;

		/* use bundled object/function symbol for matching */

		sym = sym->sec->sym;

	}

	if (sym->type != STT_OBJECT || sym->bind != STB_LOCAL)

		return 0;

	for (prefix = prefixes; *prefix; prefix++)

		if (!strncmp(sym->name, *prefix, strlen(*prefix)))

			return 1;

	return 0;

}

/*

 * This is like strcmp, but for gcc-mangled symbols.  It skips the comparison

 * of any substring which consists of '.' followed by any number of digits.

 */

static int kpatch_mangled_strcmp(char *s1, char *s2)

{

	/*

	 * ELF string sections aren't mangled, though they look that way.  Just

	 * compare them normally.

	 */

	if (strstr(s1, ".str1."))

		return strcmp(s1, s2);

	while (*s1 == *s2) {

		if (!*s1)

			return 0;

		if (*s1 == '.' && isdigit(s1[1])) {

			if (!isdigit(s2[1]))

				return 1;

			while (isdigit(*++s1))

				;

			while (isdigit(*++s2))

				;

		} else {

			s1++;

			s2++;

		}

	}

	return 1;

}

static bool rela_equal(struct rela *rela1, struct rela *rela2)

{

	struct rela *rela_toc1, *rela_toc2;

	unsigned long toc_data1 = 0, toc_data2 = 0; /* = 0 to prevent gcc warning */

	if (rela1->type != rela2->type ||

	    rela1->offset != rela2->offset)

		return false;

	/*

	 * On x86, .altinstr_aux is used to store temporary code which allows

	 * static_cpu_has() to work before apply_alternatives() has run.  This

	 * code is completely inert for modules, because apply_alternatives()

	 * runs during module init, before the module is fully formed.  Any

	 * changed references to it (i.e. changed addend) can be ignored.  As

	 * long as they're both references to .altinstr_aux, they can be

	 * considered equal, even if the addends differ.

	 */

	if (!strcmp(rela1->sym->name, ".altinstr_aux") &&

	    !strcmp(rela2->sym->name, ".altinstr_aux"))

		return true;

	/*

	 * With -mcmodel=large on ppc64le, GCC might generate entries in the .toc

	 * section for relocation symbol references.   The .toc offsets may change

	 * between the original and patched .o, so comparing ".toc + offset" isn't

	 * right.  Compare the .toc-based symbols by reading the corresponding relas

	 * from the .toc section.

	 */

	rela_toc1 = toc_rela(rela1);

	if (!rela_toc1) {

		/*

		 * .toc section entries are mostly place holder for relocation entries, specified

		 * in .rela.toc section. Sometimes, .toc section may have constants as entries.

		 * These constants are not reference to any symbols, but plain instructions mostly

		 * due to some arithmetics in the functions referring them.

		 *

		 * They are referred by the functions like normal .toc entries, these entries can

		 * not be resolved to any symbols.

		 *

		 * Disassembly of section .toc:

		 *

		 * 0000000000000000 <.toc>:

		 *         ...

		 *                        148: R_PPC64_ADDR64     .data.capacity_margin

		 *  150:   0b d7 a3 70     andi.   r3,r5,55051

		 *  154:   3d 0a d7 a3     lhz     r30,2621(r23)

		 *                        158: R_PPC64_ADDR64     sched_max_numa_distance

		 *

		 * Relocation section '.rela.toc' at offset 0xadac0 contains 160 entries:

		 *     Offset             Info             Type               Symbol's Value  Symbol's Name + Addend

		 *     ...

		 * 0000000000000148  0000009100000026 R_PPC64_ADDR64         0000000000000000 .data.capacity_margin + 0

		 * 0000000000000158  000001a500000026 R_PPC64_ADDR64         0000000000000000 sched_max_numa_distance + 0

		 *

		 * Relocation section '.rela.text.select_task_rq_fair' at offset 0x90e98 contains 37 entries:

		 *     Offset             Info             Type               Symbol's Value  Symbol's Name + Addend

		 *     ...

		 * 00000000000004a0  0000008800000032 R_PPC64_TOC16_HA       0000000000000000 .toc + 148

		 * 00000000000004ac  0000008800000040 R_PPC64_TOC16_LO_DS    0000000000000000 .toc + 148

		 * 0000000000000514  0000008800000032 R_PPC64_TOC16_HA       0000000000000000 .toc + 150

		 * 000000000000051c  0000008800000040 R_PPC64_TOC16_LO_DS    0000000000000000 .toc + 150

		 */

		memcpy(&toc_data1, rela1->sym->sec->data->d_buf + rela1->addend, sizeof(toc_data1));

		if (!toc_data1)

			ERROR(".toc entry not found %s + %lx", rela1->sym->name, rela1->addend);

	}

	rela_toc2 = toc_rela(rela2);

	if (!rela_toc2) {

		memcpy(&toc_data2, rela2->sym->sec->data->d_buf + rela2->addend, sizeof(toc_data2));

		if (!toc_data2)

			ERROR(".toc entry not found %s + %lx", rela2->sym->name, rela2->addend);

	}

	if (!rela_toc1 && !rela_toc2)

		return toc_data1 == toc_data2;

	if (!rela_toc1 || !rela_toc2)

		return false;

	if (rela_toc1->string)

		return rela_toc2->string && !strcmp(rela_toc1->string, rela_toc2->string);

	if (rela_toc1->addend != rela_toc2->addend)

		return false;

	return !kpatch_mangled_strcmp(rela_toc1->sym->name, rela_toc2->sym->name);

}

static void kpatch_compare_correlated_rela_section(struct section *sec)

{

	struct rela *rela1, *rela2 = NULL;

	/*

	 * On ppc64le, don't compare the .rela.toc section.  The .toc and

	 * .rela.toc sections are included as standard elements.

	 */

	if (!strcmp(sec->name, ".rela.toc")) {

		sec->status = SAME;

		return;

	}

	rela2 = list_entry(sec->twin->relas.next, struct rela, list);

	list_for_each_entry(rela1, &sec->relas, list) {

		if (rela_equal(rela1, rela2)) {

			rela2 = list_entry(rela2->list.next, struct rela, list);

			continue;

		}

		sec->status = CHANGED;

		return;

	}

	sec->status = SAME;

}

static void kpatch_compare_correlated_nonrela_section(struct section *sec)

{

	struct section *sec1 = sec, *sec2 = sec->twin;

	if (sec1->sh.sh_type != SHT_NOBITS &&

	    memcmp(sec1->data->d_buf, sec2->data->d_buf, sec1->data->d_size))

		sec->status = CHANGED;

	else

		sec->status = SAME;

}

static void kpatch_compare_correlated_section(struct section *sec)

{

	struct section *sec1 = sec, *sec2 = sec->twin;

	/* Compare section headers (must match or fatal) */

	if (sec1->sh.sh_type != sec2->sh.sh_type ||

	    sec1->sh.sh_flags != sec2->sh.sh_flags ||

	    sec1->sh.sh_entsize != sec2->sh.sh_entsize ||

	    (sec1->sh.sh_addralign != sec2->sh.sh_addralign &&

	     !is_text_section(sec1)))

		DIFF_FATAL("%s section header details differ from %s", sec1->name, sec2->name);

	/* Short circuit for mcount sections, we rebuild regardless */

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

	    !strcmp(sec->name, "__mcount_loc")) {

		sec->status = SAME;

		goto out;

	}

	if (sec1->sh.sh_size != sec2->sh.sh_size ||

	    sec1->data->d_size != sec2->data->d_size) {

		sec->status = CHANGED;

		goto out;

	}

	if (is_rela_section(sec))

		kpatch_compare_correlated_rela_section(sec);

	else

		kpatch_compare_correlated_nonrela_section(sec);

out:

	if (sec->status == CHANGED)

		log_debug("section %s has changed\n", sec->name);

}

#ifdef __x86_64__

/*

 * Determine if a section has changed only due to a WARN* or might_sleep

 * macro call's embedding of the line number into an instruction operand.

 *

 * Warning: Hackery lies herein.  It's hopefully justified by the fact that

 * this issue is very common.

 *

 * Example WARN*:

 *

 *  938:   be 70 00 00 00          mov    $0x70,%esi

 *  93d:   48 c7 c7 00 00 00 00    mov    $0x0,%rdi

 *                         940: R_X86_64_32S       .rodata.tcp_conn_request.str1.8+0x88

 *  944:   c6 05 00 00 00 00 01    movb   $0x1,0x0(%rip)        # 94b <tcp_conn_request+0x94b>

 *                         946: R_X86_64_PC32      .data.unlikely-0x1

 *  94b:   e8 00 00 00 00          callq  950 <tcp_conn_request+0x950>

 *                         94c: R_X86_64_PC32      warn_slowpath_null-0x4

 *

 * Example might_sleep:

 *

 *  50f:   be f7 01 00 00          mov    $0x1f7,%esi

 *  514:   48 c7 c7 00 00 00 00    mov    $0x0,%rdi

 *                         517: R_X86_64_32S       .rodata.do_select.str1.8+0x98

 *  51b:   e8 00 00 00 00          callq  520 <do_select+0x520>

 *                         51c: R_X86_64_PC32      ___might_sleep-0x4

 *

 * The pattern which applies to all cases:

 * 1) immediate move of the line number to %esi

 * 2) (optional) string section rela

 * 3) (optional) __warned.xxxxx static local rela

 * 4) warn_slowpath_* or __might_sleep or some other similar rela

 */

static int kpatch_line_macro_change_only(struct section *sec)

{

	struct insn insn1, insn2;

	unsigned long start1, start2, size, offset, length;

	struct rela *rela;

	int lineonly = 0, found;

	if (sec->status != CHANGED ||

	    is_rela_section(sec) ||

	    !is_text_section(sec) ||

	    sec->sh.sh_size != sec->twin->sh.sh_size ||

	    !sec->rela ||

	    sec->rela->status != SAME)

		return 0;

	start1 = (unsigned long)sec->twin->data->d_buf;

	start2 = (unsigned long)sec->data->d_buf;

	size = sec->sh.sh_size;

	for (offset = 0; offset < size; offset += length) {

		insn_init(&insn1, (void *)(start1 + offset), 1);

		insn_init(&insn2, (void *)(start2 + offset), 1);

		insn_get_length(&insn1);

		insn_get_length(&insn2);

		length = insn1.length;

		if (!insn1.length || !insn2.length)

			ERROR("can't decode instruction in section %s at offset 0x%lx",

			      sec->name, offset);

		if (insn1.length != insn2.length)

			return 0;

		if (!memcmp((void *)start1 + offset, (void *)start2 + offset,

			    length))

			continue;

		/* verify it's a mov immediate to %edx or %esi */

		insn_get_opcode(&insn1);

		insn_get_opcode(&insn2);

		if (!(insn1.opcode.value == 0xba && insn2.opcode.value == 0xba) &&

		    !(insn1.opcode.value == 0xbe && insn2.opcode.value == 0xbe))

			return 0;

		/*

		 * Verify zero or more string relas followed by a

		 * warn_slowpath_* or another similar rela.

		 */

		found = 0;

		list_for_each_entry(rela, &sec->rela->relas, list) {

			if (rela->offset < offset + length)

				continue;

			if (rela->string)

				continue;

			if (!strncmp(rela->sym->name, "__warned.", 9))

				continue;

			if (!strncmp(rela->sym->name, "warn_slowpath_", 14) ||

			   (!strcmp(rela->sym->name, "__warn_printk")) ||

			   (!strcmp(rela->sym->name, "__might_sleep")) ||

			   (!strcmp(rela->sym->name, "___might_sleep")) ||

			   (!strcmp(rela->sym->name, "__might_fault")) ||

			   (!strcmp(rela->sym->name, "printk")) ||

			   (!strcmp(rela->sym->name, "lockdep_rcu_suspicious"))) {

				found = 1;

				break;

			}

			return 0;

		}

		if (!found)

			return 0;

		lineonly = 1;

	}

	if (!lineonly)

		ERROR("no instruction changes detected for changed section %s",

		      sec->name);

	return 1;

}

#elif __powerpc64__

#define PPC_INSTR_LEN 4

#define PPC_RA_OFFSET 16

static int kpatch_line_macro_change_only(struct section *sec)

{

	unsigned long start1, start2, size, offset;

	unsigned int instr1, instr2;

	struct rela *rela;

	int lineonly = 0, found;

	if (sec->status != CHANGED ||

	    is_rela_section(sec) ||

	    !is_text_section(sec) ||

	    sec->sh.sh_size != sec->twin->sh.sh_size ||

	    !sec->rela ||

	    sec->rela->status != SAME)

		return 0;

	start1 = (unsigned long)sec->twin->data->d_buf;

	start2 = (unsigned long)sec->data->d_buf;

	size = sec->sh.sh_size;

	for (offset = 0; offset < size; offset += PPC_INSTR_LEN) {

		if (!memcmp((void *)start1 + offset, (void *)start2 + offset,

			    PPC_INSTR_LEN))

			continue;

		instr1 = *(unsigned int *)(start1 + offset) >> PPC_RA_OFFSET;

		instr2 = *(unsigned int *)(start2 + offset) >> PPC_RA_OFFSET;

		/* verify it's a load immediate to r5 */

		if (!(instr1 == 0x38a0 && instr2 == 0x38a0))

			return 0;

		found = 0;

		list_for_each_entry(rela, &sec->rela->relas, list) {

			if (rela->offset < offset + PPC_INSTR_LEN)

				continue;

			if (toc_rela(rela) && toc_rela(rela)->string)

				continue;

			if (!strncmp(rela->sym->name, "__warned.", 9))

				continue;

			if (!strncmp(rela->sym->name, "warn_slowpath_", 14) ||

			   (!strcmp(rela->sym->name, "__warn_printk")) ||

			   (!strcmp(rela->sym->name, "__might_sleep")) ||

			   (!strcmp(rela->sym->name, "___might_sleep")) ||

			   (!strcmp(rela->sym->name, "__might_fault")) ||

			   (!strcmp(rela->sym->name, "printk")) ||

			   (!strcmp(rela->sym->name, "lockdep_rcu_suspicious"))) {

				found = 1;

				break;

			}

			return 0;

		}

		if (!found)

			return 0;

		lineonly = 1;

	}

	if (!lineonly)

		ERROR("no instruction changes detected for changed section %s",

		      sec->name);

	return 1;

}

#else

static int kpatch_line_macro_change_only(struct section *sec)

{

	return 0;

}

#endif

/*

 * Child functions with "*.cold" names don't have _fentry_ calls, but "*.part",

 * often do. In the later case, it is not necessary to include the parent

 * in the output object when the child function has changed.

 */

static bool kpatch_changed_child_needs_parent_profiling(struct symbol *sym)

{

	struct symbol *child;

	list_for_each_entry(child, &sym->children, subfunction_node) {

		if (child->has_func_profiling)

			continue;

		if (child->sec->status == CHANGED ||

		    kpatch_changed_child_needs_parent_profiling(child))

			return true;

	}

	return false;

}

static void kpatch_compare_sections(struct list_head *seclist)

{

	struct section *sec;

	/* compare all sections */

	list_for_each_entry(sec, seclist, list) {

		if (sec->twin)

			kpatch_compare_correlated_section(sec);

		else

			sec->status = NEW;

	}

	/* exclude WARN-only, might_sleep changes */

	list_for_each_entry(sec, seclist, list) {

		if (kpatch_line_macro_change_only(sec)) {

			log_debug("reverting macro / line number section %s status to SAME\n",

				  sec->name);

			sec->status = SAME;

		}

	}

	/* sync symbol status */

	list_for_each_entry(sec, seclist, list) {

		if (is_rela_section(sec)) {

			if (sec->base->sym && sec->base->sym->status != CHANGED)

				sec->base->sym->status = sec->status;

		} else {

			struct symbol *sym = sec->sym;

			if (sym && sym->status != CHANGED)

				sym->status = sec->status;

			if (sym && sym->status == SAME &&

			    kpatch_changed_child_needs_parent_profiling(sym))

				sym->status = CHANGED;

		}

	}

}

static enum subsection kpatch_subsection_type(struct section *sec)

{

	if (!strncmp(sec->name, ".text.unlikely.", 15))

		return SUBSECTION_UNLIKELY;

	if (!strncmp(sec->name, ".text.hot.", 10))

		return SUBSECTION_HOT;

	return SUBSECTION_NORMAL;

}

static int kpatch_subsection_changed(struct section *sec1, struct section *sec2)

{

	return kpatch_subsection_type(sec1) != kpatch_subsection_type(sec2);

}

static struct symbol *kpatch_get_correlated_parent(struct symbol *sym)

{

	while (sym->parent && !sym->parent->twin)

		sym = sym->parent;

	return sym->parent;

}

static void kpatch_compare_correlated_symbol(struct symbol *sym)

{

	struct symbol *sym1 = sym, *sym2 = sym->twin;

	if (sym1->sym.st_info != sym2->sym.st_info ||

	    (sym1->sec && !sym2->sec) ||

	    (sym2->sec && !sym1->sec))

		DIFF_FATAL("symbol info mismatch: %s", sym1->name);

	/*

	 * If two symbols are correlated but their sections are not, then the

	 * symbol has changed sections.  This is only allowed if the symbol is

	 * moving out of an ignored section, or moving between normal/hot/unlikely

	 * subsections.

	 */

	if (sym1->sec && sym2->sec && sym1->sec->twin != sym2->sec) {

		if ((sym2->sec->twin && sym2->sec->twin->ignore) ||

		    kpatch_subsection_changed(sym1->sec, sym2->sec))

			sym->status = CHANGED;

		else

			DIFF_FATAL("symbol changed sections: %s", sym1->name);

	}

	if (sym1->type == STT_OBJECT &&

	    sym1->sym.st_size != sym2->sym.st_size)

		DIFF_FATAL("object size mismatch: %s", sym1->name);

	if (sym1->sym.st_shndx == SHN_UNDEF ||

	     sym1->sym.st_shndx == SHN_ABS)

		sym1->status = SAME;

	/*

	 * The status of LOCAL symbols is dependent on the status of their

	 * matching section and is set during section comparison.

	 */

}

static void kpatch_compare_symbols(struct list_head *symlist)

{

	struct symbol *sym;

	list_for_each_entry(sym, symlist, list) {

		if (sym->twin)

			kpatch_compare_correlated_symbol(sym);

		else

			sym->status = NEW;

		log_debug("symbol %s is %s\n", sym->name, status_str(sym->status));

	}

}

#define CORRELATE_ELEMENT(_e1_, _e2_, kindstr)			\

do {								\

	typeof(_e1_) e1 = (_e1_);				\

	typeof(_e2_) e2 = (_e2_);				\

	e1->twin = e2;						\

	e2->twin = e1;						\

	/* set initial status, might change */			\

	e1->status = e2->status = SAME;				\

	if (strcmp(e1->name, e2->name)) {			\

		/* Rename mangled element */			\

		log_debug("renaming %s %s to %s\n",		\

			  kindstr, e2->name, e1->name);		\

		e2->name = strdup(e1->name);			\

	}							\

} while (0)

#define UNCORRELATE_ELEMENT(_elem_)				\

do {								\

	typeof(_elem_) elem = (_elem_);				\

	elem->twin->twin = NULL;				\

	elem->twin = NULL;					\

} while (0)