[ia32rtools.git] / tools / cmpmrg_text.c

/*
 * ia32rtools
 * (C) notaz, 2013,2014
 *
 * This work is licensed under the terms of 3-clause BSD license.
 * See COPYING file in the top-level directory.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <linux/coff.h>
#include <assert.h>
#include <stdint.h>

#include "my_assert.h"

/* http://www.delorie.com/djgpp/doc/coff/ */

typedef struct {
  unsigned short f_magic;         /* magic number             */
  unsigned short f_nscns;         /* number of sections       */
  unsigned int   f_timdat;        /* time & date stamp        */
  unsigned int   f_symptr;        /* file pointer to symtab   */
  unsigned int   f_nsyms;         /* number of symtab entries */
  unsigned short f_opthdr;        /* sizeof(optional hdr)     */
  unsigned short f_flags;         /* flags                    */
} FILHDR;

typedef struct {
  unsigned short magic;          /* type of file                         */
  unsigned short vstamp;         /* version stamp                        */
  unsigned int   tsize;          /* text size in bytes, padded to FW bdry*/
  unsigned int   dsize;          /* initialized data    "  "             */
  unsigned int   bsize;          /* uninitialized data  "  "             */
  unsigned int   entry;          /* entry pt.                            */
  unsigned int   text_start;     /* base of text used for this file      */
  unsigned int   data_start;     /* base of data used for this file      */
} AOUTHDR;

typedef struct {
  char           s_name[8];  /* section name                     */
  unsigned int   s_paddr;    /* physical address, aliased s_nlib */
  unsigned int   s_vaddr;    /* virtual address                  */
  unsigned int   s_size;     /* section size                     */
  unsigned int   s_scnptr;   /* file ptr to raw data for section */
  unsigned int   s_relptr;   /* file ptr to relocation           */
  unsigned int   s_lnnoptr;  /* file ptr to line numbers         */
  unsigned short s_nreloc;   /* number of relocation entries     */
  unsigned short s_nlnno;    /* number of line number entries    */
  unsigned int   s_flags;    /* flags                            */
} SCNHDR;

typedef struct {
  unsigned int  r_vaddr;   /* address of relocation      */
  unsigned int  r_symndx;  /* symbol we're adjusting for */
  unsigned short r_type;    /* type of relocation         */
} __attribute__((packed)) RELOC;

typedef struct {
  union {
    char e_name[E_SYMNMLEN];
    struct {
      unsigned int e_zeroes;
      unsigned int e_offset;
    } e;
  } e;
  unsigned int e_value;
  short e_scnum;
  unsigned short e_type;
  unsigned char e_sclass;
  unsigned char e_numaux;
} __attribute__((packed)) SYMENT;

#define C_EXT 2

struct my_symtab {
  unsigned int addr;
  //unsigned int fpos; // for patching
  unsigned int is_text:1;
  char *name;
};

struct my_sect_info {
	long scnhdr_fofs;
	long sect_fofs;
	long reloc_fofs;
	uint8_t *data;
	long size;
	RELOC *relocs;
	long reloc_cnt;
};

static int symt_cmp(const void *p1_, const void *p2_)
{
	const struct my_symtab *p1 = p1_, *p2 = p2_;
	return p1->addr - p2->addr;
}

void parse_headers(FILE *f, unsigned int *base_out,
	struct my_sect_info *sect_i,
	struct my_symtab **symtab_out, long *sym_cnt,
	struct my_symtab **raw_symtab_out, long *raw_sym_cnt)
{
	struct my_symtab *symt_txt = NULL;
	struct my_symtab *symt_all = NULL;
	char *stringtab = NULL;
	unsigned int base = 0;
	int text_scnum = 0;
	long filesize;
	char symname[9];
	long opthdr_pos;
	long reloc_size;
	FILHDR hdr;
	AOUTHDR opthdr;
	SCNHDR scnhdr;
	SYMENT syment;
	int i, s, val;
	int ret;
	
	ret = fseek(f, 0, SEEK_END);
	my_assert(ret, 0);

	filesize = ftell(f);

	ret = fseek(f, 0, SEEK_SET);
	my_assert(ret, 0);

	ret = fread(&hdr, 1, sizeof(hdr), f);
	my_assert(ret, sizeof(hdr));

	if (hdr.f_magic == 0x5a4d) // MZ
	{
		ret = fseek(f, 0x3c, SEEK_SET);
		my_assert(ret, 0);
		ret = fread(&val, 1, sizeof(val), f);
		my_assert(ret, sizeof(val));

		ret = fseek(f, val, SEEK_SET);
		my_assert(ret, 0);
		ret = fread(&val, 1, sizeof(val), f);
		my_assert(ret, sizeof(val));
		my_assert(val, 0x4550); // PE

		// should be COFF now
		ret = fread(&hdr, 1, sizeof(hdr), f);
		my_assert(ret, sizeof(hdr));
	}

	my_assert(hdr.f_magic, COFF_I386MAGIC);

	if (hdr.f_opthdr != 0)
	{
		opthdr_pos = ftell(f);

		if (hdr.f_opthdr < sizeof(opthdr))
			my_assert(1, 0);

		ret = fread(&opthdr, 1, sizeof(opthdr), f);
		my_assert(ret, sizeof(opthdr));
		my_assert(opthdr.magic, COFF_ZMAGIC);

		//printf("text_start: %x\n", opthdr.text_start);

		if (hdr.f_opthdr > sizeof(opthdr)) {
			ret = fread(&base, 1, sizeof(base), f);
			my_assert(ret, sizeof(base));
			//printf("base: %x\n", base);
		}
		ret = fseek(f, opthdr_pos + hdr.f_opthdr, SEEK_SET);
		my_assert(ret, 0);
	}

	// note: assuming first non-empty one is .text ..
	for (s = 0; s < hdr.f_nscns; s++) {
		sect_i->scnhdr_fofs = ftell(f);

		ret = fread(&scnhdr, 1, sizeof(scnhdr), f);
		my_assert(ret, sizeof(scnhdr));

		if (scnhdr.s_size != 0) {
			text_scnum = s + 1;
			break;
		}
	}
	my_assert(s < hdr.f_nscns, 1);

#if 0
	printf("f_nsyms:  %x\n", hdr.f_nsyms);
	printf("s_name:   '%s'\n", scnhdr.s_name);
	printf("s_vaddr:  %x\n", scnhdr.s_vaddr);
	printf("s_size:   %x\n", scnhdr.s_size);
	//printf("s_scnptr: %x\n", scnhdr.s_scnptr);
	printf("s_nreloc: %x\n", scnhdr.s_nreloc);
	printf("--\n");
#endif

	ret = fseek(f, scnhdr.s_scnptr, SEEK_SET);
	my_assert(ret, 0);

	sect_i->data = malloc(scnhdr.s_size);
	my_assert_not(sect_i->data, NULL);
	ret = fread(sect_i->data, 1, scnhdr.s_size, f);
	my_assert(ret, scnhdr.s_size);

	sect_i->sect_fofs = scnhdr.s_scnptr;
	sect_i->size = scnhdr.s_size;

	// relocs
	ret = fseek(f, scnhdr.s_relptr, SEEK_SET);
	my_assert(ret, 0);

	reloc_size = scnhdr.s_nreloc * sizeof(sect_i->relocs[0]);
	sect_i->relocs = malloc(reloc_size + 1);
	my_assert_not(sect_i->relocs, NULL);
	ret = fread(sect_i->relocs, 1, reloc_size, f);
	my_assert(ret, reloc_size);

	sect_i->reloc_cnt = scnhdr.s_nreloc;
	sect_i->reloc_fofs = scnhdr.s_relptr;

	if (base != 0 && base_out != NULL)
		*base_out = base + scnhdr.s_vaddr;

	if (symtab_out == NULL || sym_cnt == NULL)
		return;

	// symtab
	if (hdr.f_nsyms != 0) {
		symname[8] = 0;

		symt_txt = malloc(hdr.f_nsyms * sizeof(symt_txt[0]) + 1);
		my_assert_not(symt_txt, NULL);
		symt_all = malloc(hdr.f_nsyms * sizeof(symt_all[0]) + 1);
		my_assert_not(symt_all, NULL);

		ret = fseek(f, hdr.f_symptr
				+ hdr.f_nsyms * sizeof(syment), SEEK_SET);
		my_assert(ret, 0);
		ret = fread(&i, 1, sizeof(i), f);
		my_assert(ret, sizeof(i));
		my_assert((unsigned int)i < filesize, 1);

		stringtab = malloc(i);
		my_assert_not(stringtab, NULL);
		memset(stringtab, 0, 4);
		ret = fread(stringtab + 4, 1, i - 4, f);
		my_assert(ret, i - 4);

		ret = fseek(f, hdr.f_symptr, SEEK_SET);
		my_assert(ret, 0);
	}

	for (i = s = 0; i < hdr.f_nsyms; i++) {
		//long pos = ftell(f);

		ret = fread(&syment, 1, sizeof(syment), f);
		my_assert(ret, sizeof(syment));

		strncpy(symname, syment.e.e_name, 8);
		//printf("%3d %2d %08x '%s'\n", syment.e_sclass,
		//	syment.e_scnum, syment.e_value, symname);

		symt_all[i].addr = syment.e_value;
		//symt_all[i].fpos = pos;
		if (syment.e.e.e_zeroes == 0)
			symt_all[i].name = stringtab + syment.e.e.e_offset;
		else
			symt_all[i].name = strdup(symname);

		symt_all[i].is_text = (syment.e_scnum == text_scnum);
		if (symt_all[i].is_text && syment.e_sclass == C_EXT) {
			symt_txt[s] = symt_all[i];
			s++;
		}

		if (syment.e_numaux) {
			ret = fseek(f, syment.e_numaux * sizeof(syment),
				    SEEK_CUR);
			my_assert(ret, 0);
			i += syment.e_numaux;
		}
	}

	if (symt_txt != NULL)
		qsort(symt_txt, s, sizeof(symt_txt[0]), symt_cmp);

	*sym_cnt = s;
	*symtab_out = symt_txt;
	*raw_sym_cnt = i;
	*raw_symtab_out = symt_all;
}

static int handle_pad(uint8_t *d_obj, uint8_t *d_exe, int maxlen)
{
	static const uint8_t p7[7] = { 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00 };
	static const uint8_t p6[6] = { 0x8d, 0x9b, 0x00, 0x00, 0x00, 0x00 };
	static const uint8_t p5[5] = { 0x05, 0x00, 0x00, 0x00, 0x00 }; // add eax, 0
	static const uint8_t p4[4] = { 0x8d, 0x64, 0x24, 0x00 }; // lea
	static const uint8_t p3[3] = { 0x8d, 0x49, 0x00 }; // lea ecx, [ecx]
	static const uint8_t p2[2] = { 0x8b, 0xff }; // mov edi, edi
	static const uint8_t p1[1] = { 0x90 }; // nop
	int len;
	int i;

	for (i = 0; i < maxlen; i++)
		if (d_exe[i] != 0xcc)
			break;

	for (len = i; len > 0; )
	{
		i = len;
		if (i > 7)
			i = 7;

		switch (i) {
		#define CASE(x) \
		case sizeof(p ## x): \
			if (memcmp(d_obj, p ## x, sizeof(p ## x))) \
				return 0; \
			memset(d_obj, 0xcc, sizeof(p ## x)); \
			break;
		CASE(7)
		CASE(6)
		CASE(5)
		CASE(4)
		CASE(3)
		CASE(2)
		CASE(1)
		default:
			printf("%s: unhandled len: %d\n", __func__, len);
			return 0;
		#undef CASE
		}

		len -= i;
		d_obj += i;
	}

	return 1;
}

struct equiv_opcode {
	signed char len;
	signed char ofs;
	unsigned short cmp_rm:1;
	unsigned short simple:1;
	uint8_t v_masm[8];
	uint8_t v_masm_mask[8];
	uint8_t v_msvc[8];
	uint8_t v_msvc_mask[8];
} equiv_ops[] = {
	// cmp    $0x11,%ax
	{ 4, -1, 0, 0,
	 { 0x66,0x83,0xf8,0x03 }, { 0xff,0xff,0xff,0x00 },
	 { 0x66,0x3d,0x03,0x00 }, { 0xff,0xff,0x00,0xff }, },
	// lea    -0x1(%ebx,%eax,1),%esi // op mod/rm sib offs
	// mov, test, imm grp 1
	{ 3, -2, 1, 0,
	 { 0x8d,0x74,0x03 }, { 0xf0,0x07,0xc0 },
	 { 0x8d,0x74,0x18 }, { 0xf0,0x07,0xc0 }, },
	// movzbl 0x58f24a(%eax,%ecx,1),%eax
	{ 4, -3, 1, 0,
	 { 0x0f,0xb6,0x84,0x08 }, { 0xff,0xff,0x07,0xc0 },
	 { 0x0f,0xb6,0x84,0x01 }, { 0xff,0xff,0x07,0xc0 }, },
	// inc/dec
	{ 3, -2, 1, 0,
	 { 0xfe,0x4c,0x03 }, { 0xfe,0xff,0xc0 },
	 { 0xfe,0x4c,0x18 }, { 0xfe,0xff,0xc0 }, },
	// cmp
	{ 3, -2, 1, 0,
	 { 0x38,0x0c,0x0c }, { 0xff,0xff,0xc0 },
	 { 0x38,0x0c,0x30 }, { 0xff,0xff,0xc0 }, },
	// test   %dl,%bl
	{ 2, -1, 1, 0,
	 { 0x84,0xd3 }, { 0xfe,0xc0 },
	 { 0x84,0xda }, { 0xfe,0xc0 }, },
	// cmp	  r,r/m vs rm/r
	{ 2, 0, 1, 0,
	 { 0x3a,0xca }, { 0xff,0xc0 },
	 { 0x38,0xd1 }, { 0xff,0xc0 }, },
	// rep + 66 prefix
	{ 2, 0, 0, 0,
	 { 0xf3,0x66 }, { 0xfe,0xff },
	 { 0x66,0xf3 }, { 0xff,0xfe }, },
	// fadd   st, st(0) vs st(0), st
	{ 2, 0, 0, 0,
	 { 0xd8,0xc0 }, { 0xff,0xf7 },
	 { 0xdc,0xc0 }, { 0xff,0xf7 }, },
	// [esp] vs [esp+0]
	{ 4, -1, 0, 0,
	 { 0x00,0x04,0x24,0x90 }, { 0x00,0xc7,0xff,0xff },
	 { 0x00,0x44,0x24,0x00 }, { 0x00,0xc7,0xff,0xff }, },
	{ 5, -1, 0, 0,
	 { 0x00,0x04,0x24,0x00,0x90 }, { 0x00,0xc7,0xff,0x00,0xff },
	 { 0x00,0x44,0x24,0x00,0x00 }, { 0x00,0xc7,0xff,0xff,0x00 }, },

        // various align insns/fillups
	{ 2, -1, 0, 0,
	 { 0x8b,0xff }, { 0xff,0xff },
	 { 0x8b,0xc0 }, { 0xff,0xff }, },
	{ 2, 0, 0, 1,
	 { 0x00,0x00 }, { 0x00,0x00 },
	 { 0x8b,0xc0 }, { 0xff,0xff }, },
	{ 3, 0, 0, 1,
	 { 0x00,0x00,0x00 }, { 0x50,0x00,0x00 },
	 { 0x2e,0x8b,0xc0 }, { 0xff,0xff,0xff }, },

	// broad filters (may take too much..)
	// testb  $0x4,0x1d(%esi,%eax,1)
	// movb, push, ..
	{ 3, -2, 1, 0,
	 { 0xf6,0x44,0x06 }, { 0x00,0x07,0xc0 },
	 { 0xf6,0x44,0x30 }, { 0x00,0x07,0xc0 }, },
};

static int cmp_mask(uint8_t *d, uint8_t *expect, uint8_t *mask, int len)
{
	int i;

	for (i = 0; i < len; i++)
		if ((d[i] & mask[i]) != (expect[i] & mask[i]))
			return 1;

	return 0;
}

static int check_equiv(uint8_t *d_obj, uint8_t *d_exe, int maxlen)
{
	uint8_t vo, ve, vo2, ve2;
	int i, jo, je;
	int len, ofs;

	for (i = 0; i < sizeof(equiv_ops) / sizeof(equiv_ops[0]); i++)
	{
		struct equiv_opcode *op = &equiv_ops[i];

		len = op->len;
		if (maxlen < len)
			continue;

		ofs = op->ofs;
		if (cmp_mask(d_obj + ofs, op->v_masm,
			     op->v_masm_mask, len))
			continue;
		if (cmp_mask(d_exe + ofs, op->v_msvc,
			     op->v_msvc_mask, len))
			continue;

		if (op->simple)
			return len + ofs;

		jo = je = 0;
		d_obj += ofs;
		d_exe += ofs;
		while (1)
		{
			for (; jo < len; jo++)
				if (op->v_masm_mask[jo] != 0xff)
					break;
			for (; je < len; je++)
				if (op->v_msvc_mask[je] != 0xff)
					break;

			if ((jo == len && je != len) || (jo != len && je == len)) {
				printf("invalid equiv_op #%ld\n", op - equiv_ops);
				return -1;
			}
			if (jo == len)
				return len + ofs; // matched

			// var byte
			vo = d_obj[jo] & ~op->v_masm_mask[jo];
			ve = d_exe[je] & ~op->v_msvc_mask[je];
			if (op->cmp_rm && op->v_masm_mask[jo] == 0xc0) {
				vo2 = vo >> 3;
				vo &= 7;
				ve2 = ve & 7;
				ve >>= 3;
				if (vo != ve || vo2 != ve2)
					return -1;
			}
			else {
				if (vo != ve)
					return -1;
			}

			jo++;
			je++;
		}
	}

	return -1;
}

static void fill_int3(unsigned char *d, int len)
{
	while (len-- > 0) {
		if (d[0] == 0xcc && d[1] == 0xcc)
			break;
		*d++ = 0xcc;
	}
}

int main(int argc, char *argv[])
{
	unsigned int base = 0, addr, end, sym, *t;
	struct my_sect_info s_text_obj, s_text_exe;
	struct my_symtab *raw_syms_obj = NULL;
	struct my_symtab *syms_obj = NULL;
	long sym_cnt_obj, raw_sym_cnt_obj;
	FILE *f_obj, *f_exe;
	SCNHDR tmphdr;
	long sztext_cmn;
	int do_cmp = 1;
	int retval = 1;
	int left;
	int arg;
	int ret;
	int i;

	for (arg = 1; arg < argc; arg++) {
		if (!strcmp(argv[arg], "-n"))
			do_cmp = 0;
		else
			break;
	}

	if (argc != arg + 2) {
		printf("usage:\n%s [-n] <a_obj> <exe>\n", argv[0]);
		return 1;
	}

	f_obj = fopen(argv[arg++], "r+b");
	if (f_obj == NULL) {
		fprintf(stderr, "%s: ", argv[1]);
		perror("");
		return 1;
	}

	f_exe = fopen(argv[arg++], "r");
	if (f_exe == NULL) {
		fprintf(stderr, "%s: ", argv[2]);
		perror("");
		return 1;
	}

	parse_headers(f_obj, NULL, &s_text_obj, &syms_obj, &sym_cnt_obj,
		      &raw_syms_obj, &raw_sym_cnt_obj);
	parse_headers(f_exe, &base, &s_text_exe, NULL, NULL, NULL, NULL);

	sztext_cmn = s_text_obj.size;
	if (sztext_cmn > s_text_exe.size)
		sztext_cmn = s_text_exe.size;

	if (sztext_cmn == 0) {
		printf("bad .text size(s): %ld, %ld\n",
			s_text_obj.size, s_text_exe.size);
		return 1;
	}

	for (i = 0; i < s_text_obj.reloc_cnt; i++)
	{
		unsigned int a = s_text_obj.relocs[i].r_vaddr;
		//printf("%04x %08x\n", s_text_obj.relocs[i].r_type, a);

		switch (s_text_obj.relocs[i].r_type) {
		case 0x06: // RELOC_ADDR32
		case 0x14: // RELOC_REL32
			// must preserve stored val,
			// so trash exe so that cmp passes
			memcpy(s_text_exe.data + a, s_text_obj.data + a, 4);
			break;
		default:
			printf("unknown reloc %x @%08x/%08x\n",
				s_text_obj.relocs[i].r_type, a, base + a);
			return 1;
		}
	}

	if (do_cmp)
	for (i = 0; i < sztext_cmn; i++)
	{
		if (s_text_obj.data[i] == s_text_exe.data[i])
			continue;

		left = sztext_cmn - i;

		if (s_text_exe.data[i] == 0xcc || s_text_exe.data[i] == 0x90) {
			// padding
			if (handle_pad(s_text_obj.data + i,
			    s_text_exe.data + i, left))
				continue;
		}

		ret = check_equiv(s_text_obj.data + i, s_text_exe.data + i, left);
		if (ret >= 0) {
			i += ret - 1;
			continue;
		}

		printf("%x: %02x vs %02x\n", base + i,
			s_text_obj.data[i], s_text_exe.data[i]);
		goto out;
	}

	// fill removed funcs with 'int3'
	for (i = 0; i < sym_cnt_obj; i++) {
		if (strncmp(syms_obj[i].name, "rm_", 3))
			continue;

		addr = syms_obj[i].addr;
		end = (i < sym_cnt_obj - 1)
			? syms_obj[i + 1].addr : s_text_obj.size;
		if (addr >= s_text_obj.size || end > s_text_obj.size) {
			printf("addr OOR: %x-%x '%s'\n", addr, end,
				syms_obj[i].name);
			goto out;
		}
		fill_int3(s_text_obj.data + addr, end - addr);
	}

	// remove relocs
	for (i = 0; i < s_text_obj.reloc_cnt; i++) {
		addr = s_text_obj.relocs[i].r_vaddr;
		sym = s_text_obj.relocs[i].r_symndx;
		if (addr > s_text_obj.size - 4) {
			printf("reloc addr OOR: %x\n", addr);
			goto out;
		}
		if (sym >= raw_sym_cnt_obj) {
			printf("reloc sym OOR: %d/%ld\n",
				sym, raw_sym_cnt_obj);
			goto out;
		}
#if 0
		printf("r %08x -> %08x %s\n", base + addr,
			raw_syms_obj[sym].addr,
			raw_syms_obj[sym].name);
#endif
		t = (unsigned int *)(s_text_obj.data + addr);
		if (t[0] == 0xcccccccc
		 || t[-1] == 0xcccccccc) { // jumptab of a func?
		 	t[0] = 0xcccccccc;
			memmove(&s_text_obj.relocs[i],
				&s_text_obj.relocs[i + 1],
				(s_text_obj.reloc_cnt - i - 1)
				 * sizeof(s_text_obj.relocs[0]));
			i--;
			s_text_obj.reloc_cnt--;
		}
#if 0
		// note: branches/calls already linked,
		// so only useful for dd refs
		// XXX: rm'd because of switch tables
		else if (raw_syms_obj[sym].is_text) {
			unsigned int addr2 = raw_syms_obj[sym].addr;
			if (s_text_obj.data[addr2] == 0xcc) {
				printf("warning: reloc %08x -> %08x "
					"points to rm'd target '%s'\n",
					base + addr, base + addr2,
					raw_syms_obj[sym].name);
			}
		}
#endif
	}

	// patch .text
	ret = fseek(f_obj, s_text_obj.sect_fofs, SEEK_SET);
	my_assert(ret, 0);
	ret = fwrite(s_text_obj.data, 1, s_text_obj.size, f_obj);
	my_assert(ret, s_text_obj.size);

	// patch relocs
	ret = fseek(f_obj, s_text_obj.reloc_fofs, SEEK_SET);
	my_assert(ret, 0);
	ret = fwrite(s_text_obj.relocs, sizeof(s_text_obj.relocs[0]),
		s_text_obj.reloc_cnt, f_obj);
	my_assert(ret, s_text_obj.reloc_cnt);

	ret = fseek(f_obj, s_text_obj.scnhdr_fofs, SEEK_SET);
	my_assert(ret, 0);
	ret = fread(&tmphdr, 1, sizeof(tmphdr), f_obj);
	my_assert(ret, sizeof(tmphdr));

	tmphdr.s_nreloc = s_text_obj.reloc_cnt;

	ret = fseek(f_obj, s_text_obj.scnhdr_fofs, SEEK_SET);
	my_assert(ret, 0);
	ret = fwrite(&tmphdr, 1, sizeof(tmphdr), f_obj);
	my_assert(ret, sizeof(tmphdr));

	fclose(f_obj);
	fclose(f_exe);

	retval = 0;
out:
	return retval;
}
Commit	Line	Data
7637b6cc	1	/*
	2	* ia32rtools
	3	* (C) notaz, 2013,2014
	4	*
	5	* This work is licensed under the terms of 3-clause BSD license.
	6	* See COPYING file in the top-level directory.
	7	*/
	8
cfd23479	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <string.h>
	12	#include <linux/coff.h>
	13	#include <assert.h>
	14	#include <stdint.h>
	15
ede51255	16	#include "my_assert.h"
ede51255	17
cfd23479	18	/* http://www.delorie.com/djgpp/doc/coff/ */
	19
	20	typedef struct {
	21	unsigned short f_magic; /* magic number */
	22	unsigned short f_nscns; /* number of sections */
	23	unsigned int f_timdat; /* time & date stamp */
	24	unsigned int f_symptr; /* file pointer to symtab */
	25	unsigned int f_nsyms; /* number of symtab entries */
	26	unsigned short f_opthdr; /* sizeof(optional hdr) */
	27	unsigned short f_flags; /* flags */
	28	} FILHDR;
	29
	30	typedef struct {
	31	unsigned short magic; /* type of file */
	32	unsigned short vstamp; /* version stamp */
	33	unsigned int tsize; /* text size in bytes, padded to FW bdry*/
	34	unsigned int dsize; /* initialized data " " */
	35	unsigned int bsize; /* uninitialized data " " */
	36	unsigned int entry; /* entry pt. */
	37	unsigned int text_start; /* base of text used for this file */
	38	unsigned int data_start; /* base of data used for this file */
	39	} AOUTHDR;
	40
	41	typedef struct {
	42	char s_name[8]; /* section name */
	43	unsigned int s_paddr; /* physical address, aliased s_nlib */
	44	unsigned int s_vaddr; /* virtual address */
	45	unsigned int s_size; /* section size */
	46	unsigned int s_scnptr; /* file ptr to raw data for section */
	47	unsigned int s_relptr; /* file ptr to relocation */
	48	unsigned int s_lnnoptr; /* file ptr to line numbers */
	49	unsigned short s_nreloc; /* number of relocation entries */
	50	unsigned short s_nlnno; /* number of line number entries */
	51	unsigned int s_flags; /* flags */
	52	} SCNHDR;
	53
	54	typedef struct {
	55	unsigned int r_vaddr; /* address of relocation */
	56	unsigned int r_symndx; /* symbol we're adjusting for */
	57	unsigned short r_type; /* type of relocation */
	58	} __attribute__((packed)) RELOC;
	59
e86c9ee6	60	typedef struct {
	61	union {
	62	char e_name[E_SYMNMLEN];
	63	struct {
	64	unsigned int e_zeroes;
	65	unsigned int e_offset;
	66	} e;
	67	} e;
	68	unsigned int e_value;
	69	short e_scnum;
	70	unsigned short e_type;
	71	unsigned char e_sclass;
	72	unsigned char e_numaux;
	73	} __attribute__((packed)) SYMENT;
	74
	75	#define C_EXT 2
	76
	77	struct my_symtab {
	78	unsigned int addr;
a2f78da4	79	//unsigned int fpos; // for patching
a2f78da4	80	unsigned int is_text:1;
e86c9ee6	81	char *name;
	82	};
	83
572a6bea	84	struct my_sect_info {
	85	long scnhdr_fofs;
	86	long sect_fofs;
	87	long reloc_fofs;
	88	uint8_t *data;
	89	long size;
	90	RELOC *relocs;
	91	long reloc_cnt;
	92	};
	93
e86c9ee6	94	static int symt_cmp(const void p1_, const void p2_)
	95	{
	96	const struct my_symtab p1 = p1_, p2 = p2_;
	97	return p1->addr - p2->addr;
	98	}
	99
cfd23479	100	void parse_headers(FILE f, unsigned int base_out,
572a6bea	101	struct my_sect_info *sect_i,
a2f78da4	102	struct my_symtab *symtab_out, long sym_cnt,
a2f78da4	103	struct my_symtab *raw_symtab_out, long raw_sym_cnt)
cfd23479	104	{
a2f78da4	105	struct my_symtab *symt_txt = NULL;
a2f78da4	106	struct my_symtab *symt_all = NULL;
e86c9ee6	107	char *stringtab = NULL;
cfd23479	108	unsigned int base = 0;
e86c9ee6	109	int text_scnum = 0;
	110	long filesize;
	111	char symname[9];
cfd23479	112	long opthdr_pos;
	113	long reloc_size;
	114	FILHDR hdr;
	115	AOUTHDR opthdr;
	116	SCNHDR scnhdr;
e86c9ee6	117	SYMENT syment;
e86c9ee6	118	int i, s, val;
cfd23479	119	int ret;
cfd23479	120
e86c9ee6	121	ret = fseek(f, 0, SEEK_END);
	122	my_assert(ret, 0);
	123
	124	filesize = ftell(f);
	125
	126	ret = fseek(f, 0, SEEK_SET);
	127	my_assert(ret, 0);
	128
cfd23479	129	ret = fread(&hdr, 1, sizeof(hdr), f);
	130	my_assert(ret, sizeof(hdr));
	131
	132	if (hdr.f_magic == 0x5a4d) // MZ
	133	{
	134	ret = fseek(f, 0x3c, SEEK_SET);
	135	my_assert(ret, 0);
	136	ret = fread(&val, 1, sizeof(val), f);
	137	my_assert(ret, sizeof(val));
	138
	139	ret = fseek(f, val, SEEK_SET);
	140	my_assert(ret, 0);
	141	ret = fread(&val, 1, sizeof(val), f);
	142	my_assert(ret, sizeof(val));
	143	my_assert(val, 0x4550); // PE
	144
	145	// should be COFF now
	146	ret = fread(&hdr, 1, sizeof(hdr), f);
	147	my_assert(ret, sizeof(hdr));
	148	}
	149
	150	my_assert(hdr.f_magic, COFF_I386MAGIC);
	151
	152	if (hdr.f_opthdr != 0)
	153	{
	154	opthdr_pos = ftell(f);
	155
	156	if (hdr.f_opthdr < sizeof(opthdr))
	157	my_assert(1, 0);
	158
	159	ret = fread(&opthdr, 1, sizeof(opthdr), f);
	160	my_assert(ret, sizeof(opthdr));
	161	my_assert(opthdr.magic, COFF_ZMAGIC);
	162
2c605b97	163	//printf("text_start: %x\n", opthdr.text_start);
cfd23479	164
	165	if (hdr.f_opthdr > sizeof(opthdr)) {
	166	ret = fread(&base, 1, sizeof(base), f);
	167	my_assert(ret, sizeof(base));
2c605b97	168	//printf("base: %x\n", base);
cfd23479	169	}
	170	ret = fseek(f, opthdr_pos + hdr.f_opthdr, SEEK_SET);
	171	my_assert(ret, 0);
	172	}
	173
e86c9ee6	174	// note: assuming first non-empty one is .text ..
cfd23479	175	for (s = 0; s < hdr.f_nscns; s++) {
572a6bea	176	sect_i->scnhdr_fofs = ftell(f);
572a6bea	177
cfd23479	178	ret = fread(&scnhdr, 1, sizeof(scnhdr), f);
	179	my_assert(ret, sizeof(scnhdr));
	180
e86c9ee6	181	if (scnhdr.s_size != 0) {
e86c9ee6	182	text_scnum = s + 1;
cfd23479	183	break;
e86c9ee6	184	}
cfd23479	185	}
572a6bea	186	my_assert(s < hdr.f_nscns, 1);
cfd23479	187
2c605b97	188	#if 0
e86c9ee6	189	printf("f_nsyms: %x\n", hdr.f_nsyms);
cfd23479	190	printf("s_name: '%s'\n", scnhdr.s_name);
	191	printf("s_vaddr: %x\n", scnhdr.s_vaddr);
	192	printf("s_size: %x\n", scnhdr.s_size);
e86c9ee6	193	//printf("s_scnptr: %x\n", scnhdr.s_scnptr);
cfd23479	194	printf("s_nreloc: %x\n", scnhdr.s_nreloc);
cfd23479	195	printf("--\n");
2c605b97	196	#endif
cfd23479	197
	198	ret = fseek(f, scnhdr.s_scnptr, SEEK_SET);
	199	my_assert(ret, 0);
	200
572a6bea	201	sect_i->data = malloc(scnhdr.s_size);
	202	my_assert_not(sect_i->data, NULL);
	203	ret = fread(sect_i->data, 1, scnhdr.s_size, f);
cfd23479	204	my_assert(ret, scnhdr.s_size);
cfd23479	205
572a6bea	206	sect_i->sect_fofs = scnhdr.s_scnptr;
572a6bea	207	sect_i->size = scnhdr.s_size;
cfd23479	208
e86c9ee6	209	// relocs
cfd23479	210	ret = fseek(f, scnhdr.s_relptr, SEEK_SET);
	211	my_assert(ret, 0);
	212
572a6bea	213	reloc_size = scnhdr.s_nreloc * sizeof(sect_i->relocs[0]);
	214	sect_i->relocs = malloc(reloc_size + 1);
	215	my_assert_not(sect_i->relocs, NULL);
	216	ret = fread(sect_i->relocs, 1, reloc_size, f);
cfd23479	217	my_assert(ret, reloc_size);
cfd23479	218
572a6bea	219	sect_i->reloc_cnt = scnhdr.s_nreloc;
	220	sect_i->reloc_fofs = scnhdr.s_relptr;
	221
	222	if (base != 0 && base_out != NULL)
	223	*base_out = base + scnhdr.s_vaddr;
	224
	225	if (symtab_out == NULL \|\| sym_cnt == NULL)
	226	return;
cfd23479	227
e86c9ee6	228	// symtab
	229	if (hdr.f_nsyms != 0) {
	230	symname[8] = 0;
	231
a2f78da4	232	symt_txt = malloc(hdr.f_nsyms * sizeof(symt_txt[0]) + 1);
	233	my_assert_not(symt_txt, NULL);
	234	symt_all = malloc(hdr.f_nsyms * sizeof(symt_all[0]) + 1);
	235	my_assert_not(symt_all, NULL);
e86c9ee6	236
	237	ret = fseek(f, hdr.f_symptr
	238	+ hdr.f_nsyms * sizeof(syment), SEEK_SET);
	239	my_assert(ret, 0);
	240	ret = fread(&i, 1, sizeof(i), f);
	241	my_assert(ret, sizeof(i));
	242	my_assert((unsigned int)i < filesize, 1);
	243
	244	stringtab = malloc(i);
	245	my_assert_not(stringtab, NULL);
	246	memset(stringtab, 0, 4);
	247	ret = fread(stringtab + 4, 1, i - 4, f);
	248	my_assert(ret, i - 4);
	249
	250	ret = fseek(f, hdr.f_symptr, SEEK_SET);
	251	my_assert(ret, 0);
	252	}
	253
	254	for (i = s = 0; i < hdr.f_nsyms; i++) {
a2f78da4	255	//long pos = ftell(f);
e86c9ee6	256
	257	ret = fread(&syment, 1, sizeof(syment), f);
	258	my_assert(ret, sizeof(syment));
	259
	260	strncpy(symname, syment.e.e_name, 8);
	261	//printf("%3d %2d %08x '%s'\n", syment.e_sclass,
	262	// syment.e_scnum, syment.e_value, symname);
	263
a2f78da4	264	symt_all[i].addr = syment.e_value;
a2f78da4	265	//symt_all[i].fpos = pos;
e86c9ee6	266	if (syment.e.e.e_zeroes == 0)
a2f78da4	267	symt_all[i].name = stringtab + syment.e.e.e_offset;
e86c9ee6	268	else
a2f78da4	269	symt_all[i].name = strdup(symname);
	270
	271	symt_all[i].is_text = (syment.e_scnum == text_scnum);
	272	if (symt_all[i].is_text && syment.e_sclass == C_EXT) {
	273	symt_txt[s] = symt_all[i];
	274	s++;
	275	}
e86c9ee6	276
	277	if (syment.e_numaux) {
	278	ret = fseek(f, syment.e_numaux * sizeof(syment),
	279	SEEK_CUR);
	280	my_assert(ret, 0);
	281	i += syment.e_numaux;
	282	}
	283	}
	284
a2f78da4	285	if (symt_txt != NULL)
a2f78da4	286	qsort(symt_txt, s, sizeof(symt_txt[0]), symt_cmp);
e86c9ee6	287
e86c9ee6	288	*sym_cnt = s;
a2f78da4	289	*symtab_out = symt_txt;
	290	*raw_sym_cnt = i;
	291	*raw_symtab_out = symt_all;
cfd23479	292	}
	293
	294	static int handle_pad(uint8_t d_obj, uint8_t d_exe, int maxlen)
	295	{
	296	static const uint8_t p7[7] = { 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00 };
	297	static const uint8_t p6[6] = { 0x8d, 0x9b, 0x00, 0x00, 0x00, 0x00 };
3ebea2cf	298	static const uint8_t p5[5] = { 0x05, 0x00, 0x00, 0x00, 0x00 }; // add eax, 0
	299	static const uint8_t p4[4] = { 0x8d, 0x64, 0x24, 0x00 }; // lea
	300	static const uint8_t p3[3] = { 0x8d, 0x49, 0x00 }; // lea ecx, [ecx]
	301	static const uint8_t p2[2] = { 0x8b, 0xff }; // mov edi, edi
	302	static const uint8_t p1[1] = { 0x90 }; // nop
cfd23479	303	int len;
	304	int i;
	305
	306	for (i = 0; i < maxlen; i++)
	307	if (d_exe[i] != 0xcc)
	308	break;
	309
	310	for (len = i; len > 0; )
	311	{
	312	i = len;
	313	if (i > 7)
	314	i = 7;
	315
	316	switch (i) {
	317	#define CASE(x) \
	318	case sizeof(p ## x): \
	319	if (memcmp(d_obj, p ## x, sizeof(p ## x))) \
	320	return 0; \
	321	memset(d_obj, 0xcc, sizeof(p ## x)); \
	322	break;
	323	CASE(7)
	324	CASE(6)
	325	CASE(5)
	326	CASE(4)
	327	CASE(3)
	328	CASE(2)
	329	CASE(1)
	330	default:
	331	printf("%s: unhandled len: %d\n", __func__, len);
	332	return 0;
	333	#undef CASE
	334	}
	335
	336	len -= i;
	337	d_obj += i;
	338	}
	339
	340	return 1;
	341	}
	342
	343	struct equiv_opcode {
	344	signed char len;
	345	signed char ofs;
ed6ebb48	346	unsigned short cmp_rm:1;
ed6ebb48	347	unsigned short simple:1;
cfd23479	348	uint8_t v_masm[8];
	349	uint8_t v_masm_mask[8];
	350	uint8_t v_msvc[8];
	351	uint8_t v_msvc_mask[8];
	352	} equiv_ops[] = {
	353	// cmp $0x11,%ax
ed6ebb48	354	{ 4, -1, 0, 0,
cfd23479	355	{ 0x66,0x83,0xf8,0x03 }, { 0xff,0xff,0xff,0x00 },
	356	{ 0x66,0x3d,0x03,0x00 }, { 0xff,0xff,0x00,0xff }, },
	357	// lea -0x1(%ebx,%eax,1),%esi // op mod/rm sib offs
	358	// mov, test, imm grp 1
ed6ebb48	359	{ 3, -2, 1, 0,
cfd23479	360	{ 0x8d,0x74,0x03 }, { 0xf0,0x07,0xc0 },
	361	{ 0x8d,0x74,0x18 }, { 0xf0,0x07,0xc0 }, },
	362	// movzbl 0x58f24a(%eax,%ecx,1),%eax
ed6ebb48	363	{ 4, -3, 1, 0,
cfd23479	364	{ 0x0f,0xb6,0x84,0x08 }, { 0xff,0xff,0x07,0xc0 },
	365	{ 0x0f,0xb6,0x84,0x01 }, { 0xff,0xff,0x07,0xc0 }, },
	366	// inc/dec
ed6ebb48	367	{ 3, -2, 1, 0,
cfd23479	368	{ 0xfe,0x4c,0x03 }, { 0xfe,0xff,0xc0 },
	369	{ 0xfe,0x4c,0x18 }, { 0xfe,0xff,0xc0 }, },
	370	// cmp
ed6ebb48	371	{ 3, -2, 1, 0,
cfd23479	372	{ 0x38,0x0c,0x0c }, { 0xff,0xff,0xc0 },
	373	{ 0x38,0x0c,0x30 }, { 0xff,0xff,0xc0 }, },
	374	// test %dl,%bl
ed6ebb48	375	{ 2, -1, 1, 0,
cfd23479	376	{ 0x84,0xd3 }, { 0xfe,0xc0 },
	377	{ 0x84,0xda }, { 0xfe,0xc0 }, },
	378	// cmp r,r/m vs rm/r
ed6ebb48	379	{ 2, 0, 1, 0,
cfd23479	380	{ 0x3a,0xca }, { 0xff,0xc0 },
	381	{ 0x38,0xd1 }, { 0xff,0xc0 }, },
	382	// rep + 66 prefix
ed6ebb48	383	{ 2, 0, 0, 0,
cfd23479	384	{ 0xf3,0x66 }, { 0xfe,0xff },
	385	{ 0x66,0xf3 }, { 0xff,0xfe }, },
	386	// fadd st, st(0) vs st(0), st
ed6ebb48	387	{ 2, 0, 0, 0,
cfd23479	388	{ 0xd8,0xc0 }, { 0xff,0xf7 },
cfd23479	389	{ 0xdc,0xc0 }, { 0xff,0xf7 }, },
ed6ebb48	390	// [esp] vs [esp+0]
	391	{ 4, -1, 0, 0,
	392	{ 0x00,0x04,0x24,0x90 }, { 0x00,0xc7,0xff,0xff },
	393	{ 0x00,0x44,0x24,0x00 }, { 0x00,0xc7,0xff,0xff }, },
	394	{ 5, -1, 0, 0,
	395	{ 0x00,0x04,0x24,0x00,0x90 }, { 0x00,0xc7,0xff,0x00,0xff },
	396	{ 0x00,0x44,0x24,0x00,0x00 }, { 0x00,0xc7,0xff,0xff,0x00 }, },
	397
	398	// various align insns/fillups
	399	{ 2, -1, 0, 0,
	400	{ 0x8b,0xff }, { 0xff,0xff },
	401	{ 0x8b,0xc0 }, { 0xff,0xff }, },
	402	{ 2, 0, 0, 1,
	403	{ 0x00,0x00 }, { 0x00,0x00 },
	404	{ 0x8b,0xc0 }, { 0xff,0xff }, },
	405	{ 3, 0, 0, 1,
	406	{ 0x00,0x00,0x00 }, { 0x50,0x00,0x00 },
	407	{ 0x2e,0x8b,0xc0 }, { 0xff,0xff,0xff }, },
cfd23479	408
	409	// broad filters (may take too much..)
	410	// testb $0x4,0x1d(%esi,%eax,1)
	411	// movb, push, ..
ed6ebb48	412	{ 3, -2, 1, 0,
cfd23479	413	{ 0xf6,0x44,0x06 }, { 0x00,0x07,0xc0 },
	414	{ 0xf6,0x44,0x30 }, { 0x00,0x07,0xc0 }, },
	415	};
	416
	417	static int cmp_mask(uint8_t d, uint8_t expect, uint8_t *mask, int len)
	418	{
	419	int i;
	420
	421	for (i = 0; i < len; i++)
	422	if ((d[i] & mask[i]) != (expect[i] & mask[i]))
	423	return 1;
	424
	425	return 0;
	426	}
	427
	428	static int check_equiv(uint8_t d_obj, uint8_t d_exe, int maxlen)
	429	{
	430	uint8_t vo, ve, vo2, ve2;
	431	int i, jo, je;
	432	int len, ofs;
	433
	434	for (i = 0; i < sizeof(equiv_ops) / sizeof(equiv_ops[0]); i++)
	435	{
	436	struct equiv_opcode *op = &equiv_ops[i];
	437
	438	len = op->len;
	439	if (maxlen < len)
	440	continue;
	441
	442	ofs = op->ofs;
	443	if (cmp_mask(d_obj + ofs, op->v_masm,
	444	op->v_masm_mask, len))
	445	continue;
	446	if (cmp_mask(d_exe + ofs, op->v_msvc,
	447	op->v_msvc_mask, len))
	448	continue;
	449
ed6ebb48	450	if (op->simple)
	451	return len + ofs;
	452
cfd23479	453	jo = je = 0;
	454	d_obj += ofs;
	455	d_exe += ofs;
	456	while (1)
	457	{
	458	for (; jo < len; jo++)
	459	if (op->v_masm_mask[jo] != 0xff)
	460	break;
	461	for (; je < len; je++)
	462	if (op->v_msvc_mask[je] != 0xff)
	463	break;
	464
	465	if ((jo == len && je != len) \|\| (jo != len && je == len)) {
ed6ebb48	466	printf("invalid equiv_op #%ld\n", op - equiv_ops);
cfd23479	467	return -1;
	468	}
	469	if (jo == len)
ed6ebb48	470	return len + ofs; // matched
cfd23479	471
	472	// var byte
	473	vo = d_obj[jo] & ~op->v_masm_mask[jo];
	474	ve = d_exe[je] & ~op->v_msvc_mask[je];
	475	if (op->cmp_rm && op->v_masm_mask[jo] == 0xc0) {
	476	vo2 = vo >> 3;
	477	vo &= 7;
	478	ve2 = ve & 7;
	479	ve >>= 3;
	480	if (vo != ve \|\| vo2 != ve2)
	481	return -1;
	482	}
	483	else {
	484	if (vo != ve)
	485	return -1;
	486	}
	487
	488	jo++;
	489	je++;
	490	}
	491	}
	492
	493	return -1;
	494	}
	495
572a6bea	496	static void fill_int3(unsigned char *d, int len)
	497	{
	498	while (len-- > 0) {
a2f78da4	499	if (d[0] == 0xcc && d[1] == 0xcc)
572a6bea	500	break;
	501	*d++ = 0xcc;
	502	}
	503	}
	504
cfd23479	505	int main(int argc, char *argv[])
cfd23479	506	{
de50b98b	507	unsigned int base = 0, addr, end, sym, *t;
572a6bea	508	struct my_sect_info s_text_obj, s_text_exe;
a2f78da4	509	struct my_symtab *raw_syms_obj = NULL;
572a6bea	510	struct my_symtab *syms_obj = NULL;
a2f78da4	511	long sym_cnt_obj, raw_sym_cnt_obj;
cfd23479	512	FILE f_obj, f_exe;
572a6bea	513	SCNHDR tmphdr;
572a6bea	514	long sztext_cmn;
c0d9cac6	515	int do_cmp = 1;
cfd23479	516	int retval = 1;
cfd23479	517	int left;
c0d9cac6	518	int arg;
cfd23479	519	int ret;
	520	int i;
	521
c0d9cac6	522	for (arg = 1; arg < argc; arg++) {
	523	if (!strcmp(argv[arg], "-n"))
	524	do_cmp = 0;
	525	else
	526	break;
	527	}
	528
	529	if (argc != arg + 2) {
	530	printf("usage:\n%s [-n] <a_obj> <exe>\n", argv[0]);
cfd23479	531	return 1;
	532	}
	533
c0d9cac6	534	f_obj = fopen(argv[arg++], "r+b");
cfd23479	535	if (f_obj == NULL) {
3ebea2cf	536	fprintf(stderr, "%s: ", argv[1]);
cfd23479	537	perror("");
	538	return 1;
	539	}
	540
c0d9cac6	541	f_exe = fopen(argv[arg++], "r");
cfd23479	542	if (f_exe == NULL) {
3ebea2cf	543	fprintf(stderr, "%s: ", argv[2]);
cfd23479	544	perror("");
	545	return 1;
	546	}
	547
a2f78da4	548	parse_headers(f_obj, NULL, &s_text_obj, &syms_obj, &sym_cnt_obj,
	549	&raw_syms_obj, &raw_sym_cnt_obj);
	550	parse_headers(f_exe, &base, &s_text_exe, NULL, NULL, NULL, NULL);
cfd23479	551
572a6bea	552	sztext_cmn = s_text_obj.size;
	553	if (sztext_cmn > s_text_exe.size)
	554	sztext_cmn = s_text_exe.size;
cfd23479	555
	556	if (sztext_cmn == 0) {
	557	printf("bad .text size(s): %ld, %ld\n",
572a6bea	558	s_text_obj.size, s_text_exe.size);
cfd23479	559	return 1;
	560	}
	561
572a6bea	562	for (i = 0; i < s_text_obj.reloc_cnt; i++)
cfd23479	563	{
572a6bea	564	unsigned int a = s_text_obj.relocs[i].r_vaddr;
572a6bea	565	//printf("%04x %08x\n", s_text_obj.relocs[i].r_type, a);
cfd23479	566
572a6bea	567	switch (s_text_obj.relocs[i].r_type) {
2c605b97	568	case 0x06: // RELOC_ADDR32
	569	case 0x14: // RELOC_REL32
	570	// must preserve stored val,
572a6bea	571	// so trash exe so that cmp passes
572a6bea	572	memcpy(s_text_exe.data + a, s_text_obj.data + a, 4);
cfd23479	573	break;
cfd23479	574	default:
2c605b97	575	printf("unknown reloc %x @%08x/%08x\n",
572a6bea	576	s_text_obj.relocs[i].r_type, a, base + a);
cfd23479	577	return 1;
	578	}
	579	}
	580
c0d9cac6	581	if (do_cmp)
cfd23479	582	for (i = 0; i < sztext_cmn; i++)
cfd23479	583	{
572a6bea	584	if (s_text_obj.data[i] == s_text_exe.data[i])
cfd23479	585	continue;
	586
	587	left = sztext_cmn - i;
	588
ed6ebb48	589	if (s_text_exe.data[i] == 0xcc \|\| s_text_exe.data[i] == 0x90) {
ed6ebb48	590	// padding
572a6bea	591	if (handle_pad(s_text_obj.data + i,
572a6bea	592	s_text_exe.data + i, left))
cfd23479	593	continue;
	594	}
	595
572a6bea	596	ret = check_equiv(s_text_obj.data + i, s_text_exe.data + i, left);
cfd23479	597	if (ret >= 0) {
ed6ebb48	598	i += ret - 1;
cfd23479	599	continue;
	600	}
	601
572a6bea	602	printf("%x: %02x vs %02x\n", base + i,
572a6bea	603	s_text_obj.data[i], s_text_exe.data[i]);
cfd23479	604	goto out;
	605	}
	606
572a6bea	607	// fill removed funcs with 'int3'
2c605b97	608	for (i = 0; i < sym_cnt_obj; i++) {
	609	if (strncmp(syms_obj[i].name, "rm_", 3))
	610	continue;
	611
	612	addr = syms_obj[i].addr;
	613	end = (i < sym_cnt_obj - 1)
572a6bea	614	? syms_obj[i + 1].addr : s_text_obj.size;
572a6bea	615	if (addr >= s_text_obj.size \|\| end > s_text_obj.size) {
2c605b97	616	printf("addr OOR: %x-%x '%s'\n", addr, end,
	617	syms_obj[i].name);
	618	goto out;
	619	}
572a6bea	620	fill_int3(s_text_obj.data + addr, end - addr);
	621	}
	622
	623	// remove relocs
	624	for (i = 0; i < s_text_obj.reloc_cnt; i++) {
	625	addr = s_text_obj.relocs[i].r_vaddr;
a2f78da4	626	sym = s_text_obj.relocs[i].r_symndx;
572a6bea	627	if (addr > s_text_obj.size - 4) {
	628	printf("reloc addr OOR: %x\n", addr);
	629	goto out;
	630	}
a2f78da4	631	if (sym >= raw_sym_cnt_obj) {
	632	printf("reloc sym OOR: %d/%ld\n",
	633	sym, raw_sym_cnt_obj);
	634	goto out;
	635	}
	636	#if 0
	637	printf("r %08x -> %08x %s\n", base + addr,
	638	raw_syms_obj[sym].addr,
	639	raw_syms_obj[sym].name);
	640	#endif
	641	t = (unsigned int *)(s_text_obj.data + addr);
	642	if (t[0] == 0xcccccccc
	643	\|\| t[-1] == 0xcccccccc) { // jumptab of a func?
	644	t[0] = 0xcccccccc;
572a6bea	645	memmove(&s_text_obj.relocs[i],
	646	&s_text_obj.relocs[i + 1],
	647	(s_text_obj.reloc_cnt - i - 1)
	648	* sizeof(s_text_obj.relocs[0]));
	649	i--;
	650	s_text_obj.reloc_cnt--;
	651	}
de50b98b	652	#if 0
a2f78da4	653	// note: branches/calls already linked,
a2f78da4	654	// so only useful for dd refs
de50b98b	655	// XXX: rm'd because of switch tables
a2f78da4	656	else if (raw_syms_obj[sym].is_text) {
de50b98b	657	unsigned int addr2 = raw_syms_obj[sym].addr;
a2f78da4	658	if (s_text_obj.data[addr2] == 0xcc) {
	659	printf("warning: reloc %08x -> %08x "
	660	"points to rm'd target '%s'\n",
	661	base + addr, base + addr2,
	662	raw_syms_obj[sym].name);
	663	}
	664	}
de50b98b	665	#endif
2c605b97	666	}
2c605b97	667
572a6bea	668	// patch .text
	669	ret = fseek(f_obj, s_text_obj.sect_fofs, SEEK_SET);
	670	my_assert(ret, 0);
	671	ret = fwrite(s_text_obj.data, 1, s_text_obj.size, f_obj);
	672	my_assert(ret, s_text_obj.size);
	673
	674	// patch relocs
	675	ret = fseek(f_obj, s_text_obj.reloc_fofs, SEEK_SET);
	676	my_assert(ret, 0);
	677	ret = fwrite(s_text_obj.relocs, sizeof(s_text_obj.relocs[0]),
	678	s_text_obj.reloc_cnt, f_obj);
	679	my_assert(ret, s_text_obj.reloc_cnt);
	680
	681	ret = fseek(f_obj, s_text_obj.scnhdr_fofs, SEEK_SET);
	682	my_assert(ret, 0);
	683	ret = fread(&tmphdr, 1, sizeof(tmphdr), f_obj);
	684	my_assert(ret, sizeof(tmphdr));
	685
	686	tmphdr.s_nreloc = s_text_obj.reloc_cnt;
	687
	688	ret = fseek(f_obj, s_text_obj.scnhdr_fofs, SEEK_SET);
	689	my_assert(ret, 0);
	690	ret = fwrite(&tmphdr, 1, sizeof(tmphdr), f_obj);
	691	my_assert(ret, sizeof(tmphdr));
2c605b97	692
	693	fclose(f_obj);
	694	fclose(f_exe);
	695
	696	retval = 0;
cfd23479	697	out:
	698	return retval;
	699	}