/*

 * 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 loglevel loglevel = NORMAL;

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

 * 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_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, ".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

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;

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

	return find_rela_by_offset(rela->sym->sec->rela, 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;

		}

	}

}

/*

 * 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.",

		"descriptor.",

		"__func__.",

		"_rs.",

		"CSWTCH.",

		NULL,

	};

	char **prefix;

	if (!sym)

		return 0;

	if (sym->type == STT_SECTION) {

		/* __verbose section contains the descriptor variables */

		if (!strcmp(sym->name, "__verbose"))

			return 1;

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

{

	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 int 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 0;

	/*

	 * 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 + %x", 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 + %x", rela2->sym->name, rela2->addend);

	}

	if (!rela_toc1 && !rela_toc2)

		return toc_data1 == toc_data2;

	if (rela_toc1->string)

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

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

		return 0;

	if (is_special_static(rela_toc1->sym))

		return !kpatch_mangled_strcmp(rela_toc1->sym->name,

					      rela_toc2->sym->name);

	return !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_addralign != sec2->sh.sh_addralign ||

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

		DIFF_FATAL("%s section header details differ", sec1->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

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 {

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

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

		}

	}

}

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.

	 */

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

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

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

	}

}

static void kpatch_correlate_sections(struct list_head *seclist1, struct list_head *seclist2)

{

	struct section *sec1, *sec2;

	list_for_each_entry(sec1, seclist1, list) {

		list_for_each_entry(sec2, seclist2, list) {

			if (strcmp(sec1->name, sec2->name))

				continue;

			if (is_special_static(is_rela_section(sec1) ?

					      sec1->base->secsym :

					      sec1->secsym))

				continue;

			/*

			 * Group sections must match exactly to be correlated.

			 * Changed group sections are currently not supported.

			 */

			if (sec1->sh.sh_type == SHT_GROUP) {

				if (sec1->data->d_size != sec2->data->d_size)

					continue;

				if (memcmp(sec1->data->d_buf, sec2->data->d_buf,

				           sec1->data->d_size))

					continue;

			}

			sec1->twin = sec2;

			sec2->twin = sec1;

			/* set initial status, might change */

			sec1->status = sec2->status = SAME;

			break;

		}

	}

}

static void kpatch_correlate_symbols(struct list_head *symlist1, struct list_head *symlist2)

{

	struct symbol *sym1, *sym2;

	list_for_each_entry(sym1, symlist1, list) {

		list_for_each_entry(sym2, symlist2, list) {

			if (strcmp(sym1->name, sym2->name) ||

			    sym1->type != sym2->type)

				continue;

			if (is_special_static(sym1))

				continue;

			/*

			 * The .LCx symbols point to strings, usually used for

			 * the bug table.  Don't correlate and compare the

			 * symbols themselves, because the suffix number might

			 * change.

			 *

			 * If the symbol is used by the bug table (usual case),

			 * it may get pulled in by

			 * kpatch_regenerate_special_section().

			 *

			 * If the symbol is used outside of the bug table (not

			 * sure if this actually happens anywhere), any string

			 * changes will be detected elsewhere in rela_equal().

			 */

			if (sym1->type == STT_NOTYPE &&

			    !strncmp(sym1->name, ".LC", 3))

				continue;

			/* group section symbols must have correlated sections */

			if (sym1->sec &&

			    sym1->sec->sh.sh_type == SHT_GROUP &&

			    sym1->sec->twin != sym2->sec)

				continue;

			sym1->twin = sym2;

			sym2->twin = sym1;

			/* set initial status, might change */

			sym1->status = sym2->status = SAME;

			break;

		}

	}

}

static void kpatch_compare_elf_headers(Elf *elf1, Elf *elf2)

{

	GElf_Ehdr eh1, eh2;

	if (!gelf_getehdr(elf1, &eh1))

		ERROR("gelf_getehdr");

	if (!gelf_getehdr(elf2, &eh2))

		ERROR("gelf_getehdr");

	if (memcmp(eh1.e_ident, eh2.e_ident, EI_NIDENT) ||

	    eh1.e_type != eh2.e_type ||

	    eh1.e_machine != eh2.e_machine ||

	    eh1.e_version != eh2.e_version ||

	    eh1.e_entry != eh2.e_entry ||

	    eh1.e_phoff != eh2.e_phoff ||

	    eh1.e_flags != eh2.e_flags ||

	    eh1.e_ehsize != eh2.e_ehsize ||

	    eh1.e_phentsize != eh2.e_phentsize ||

	    eh1.e_shentsize != eh2.e_shentsize)

		DIFF_FATAL("ELF headers differ");

}

static void kpatch_check_program_headers(Elf *elf)

{

	size_t ph_nr;

	if (elf_getphdrnum(elf, &ph_nr))

		ERROR("elf_getphdrnum");

	if (ph_nr != 0)

		DIFF_FATAL("ELF contains program header");

}

static void kpatch_mark_grouped_sections(struct kpatch_elf *kelf)

{

	struct section *groupsec, *sec;

	unsigned int *data, *end;

	list_for_each_entry(groupsec, &kelf->sections, list) {

		if (groupsec->sh.sh_type != SHT_GROUP)

			continue;

		data = groupsec->data->d_buf;

		end = groupsec->data->d_buf + groupsec->data->d_size;

		data++; /* skip first flag word (e.g. GRP_COMDAT) */

		while (data < end) {

			sec = find_section_by_index(&kelf->sections, *data);

			if (!sec)

				ERROR("group section not found");

			sec->grouped = 1;

			log_debug("marking section %s (%d) as grouped\n",

			          sec->name, sec->index);

			data++;

		}

	}

}

/*

 * When gcc makes compiler optimizations which affect a function's calling

 * interface, it mangles the function's name.  For example, sysctl_print_dir is

 * renamed to sysctl_print_dir.isra.2.  The problem is that the trailing number

 * is chosen arbitrarily, and the patched version of the function may end up

 * with a different trailing number.  Rename any mangled patched functions to

 * match their base counterparts.

 */

static void kpatch_rename_mangled_functions(struct kpatch_elf *base,

					    struct kpatch_elf *patched)

{

	struct symbol *sym, *basesym;

	char name[256], *origname;

	struct section *sec, *basesec;

	int found;

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

		if (sym->type != STT_FUNC)

			continue;

		if (!strstr(sym->name, ".isra.") &&

		    !strstr(sym->name, ".constprop.") &&

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

		    !strstr(sym->name, ".part."))

			continue;

		found = 0;

		list_for_each_entry(basesym, &base->symbols, list) {

			if (!kpatch_mangled_strcmp(basesym->name, sym->name)) {

				found = 1;

				break;

			}

		}

		if (!found)

			continue;

		if (!strcmp(sym->name, basesym->name))

			continue;

		log_debug("renaming %s to %s\n", sym->name, basesym->name);

		origname = sym->name;

		sym->name = strdup(basesym->name);

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

			continue;

		sym->sec->name = strdup(basesym->sec->name);

		if (sym->sec->rela)

			sym->sec->rela->name = strdup(basesym->sec->rela->name);

		/*

		 * When function foo.isra.1 has a switch statement, it might

		 * have a corresponding bundled .rodata.foo.isra.1 section (in

		 * addition to .text.foo.isra.1 which we renamed above).

		 */

		sprintf(name, ".rodata.%s", origname);

		sec = find_section_by_name(&patched->sections, name);

		if (!sec)

			continue;

		sprintf(name, ".rodata.%s", basesym->name);

		basesec = find_section_by_name(&base->sections, name);

		if (!basesec)

			continue;

		sec->name = strdup(basesec->name);

		sec->secsym->name = sec->name;

		if (sec->rela)

			sec->rela->name = strdup(basesec->rela->name);

	}

}

static char *kpatch_section_function_name(struct section *sec)

{

	if (is_rela_section(sec))