tools/cmpmrg_text.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <linux/coff.h>
   5 #include <assert.h>
   6 #include <stdint.h>
   7
   8 #include "my_assert.h"
   9
  10 /* http://www.delorie.com/djgpp/doc/coff/ */
  11
  12 typedef struct {
  13   unsigned short f_magic;         /* magic number             */
  14   unsigned short f_nscns;         /* number of sections       */
  15   unsigned int   f_timdat;        /* time & date stamp        */
  16   unsigned int   f_symptr;        /* file pointer to symtab   */
  17   unsigned int   f_nsyms;         /* number of symtab entries */
  18   unsigned short f_opthdr;        /* sizeof(optional hdr)     */
  19   unsigned short f_flags;         /* flags                    */
  20 } FILHDR;
  21
  22 typedef struct {
  23   unsigned short magic;          /* type of file                         */
  24   unsigned short vstamp;         /* version stamp                        */
  25   unsigned int   tsize;          /* text size in bytes, padded to FW bdry*/
  26   unsigned int   dsize;          /* initialized data    "  "             */
  27   unsigned int   bsize;          /* uninitialized data  "  "             */
  28   unsigned int   entry;          /* entry pt.                            */
  29   unsigned int   text_start;     /* base of text used for this file      */
  30   unsigned int   data_start;     /* base of data used for this file      */
  31 } AOUTHDR;
  32
  33 typedef struct {
  34   char           s_name[8];  /* section name                     */
  35   unsigned int   s_paddr;    /* physical address, aliased s_nlib */
  36   unsigned int   s_vaddr;    /* virtual address                  */
  37   unsigned int   s_size;     /* section size                     */
  38   unsigned int   s_scnptr;   /* file ptr to raw data for section */
  39   unsigned int   s_relptr;   /* file ptr to relocation           */
  40   unsigned int   s_lnnoptr;  /* file ptr to line numbers         */
  41   unsigned short s_nreloc;   /* number of relocation entries     */
  42   unsigned short s_nlnno;    /* number of line number entries    */
  43   unsigned int   s_flags;    /* flags                            */
  44 } SCNHDR;
  45
  46 typedef struct {
  47   unsigned int  r_vaddr;   /* address of relocation      */
  48   unsigned int  r_symndx;  /* symbol we're adjusting for */
  49   unsigned short r_type;    /* type of relocation         */
  50 } __attribute__((packed)) RELOC;
  51
  52 typedef struct {
  53   union {
  54     char e_name[E_SYMNMLEN];
  55     struct {
  56       unsigned int e_zeroes;
  57       unsigned int e_offset;
  58     } e;
  59   } e;
  60   unsigned int e_value;
  61   short e_scnum;
  62   unsigned short e_type;
  63   unsigned char e_sclass;
  64   unsigned char e_numaux;
  65 } __attribute__((packed)) SYMENT;
  66
  67 #define C_EXT 2
  68
  69 struct my_symtab {
  70   unsigned int addr;
  71   unsigned int fpos; // for patching
  72   char *name;
  73 };
  74
  75 static int symt_cmp(const void *p1_, const void *p2_)
  76 {
  77         const struct my_symtab *p1 = p1_, *p2 = p2_;
  78         return p1->addr - p2->addr;
  79 }
  80
  81 void parse_headers(FILE *f, unsigned int *base_out,
  82         long *sect_ofs, uint8_t **sect_data, long *sect_sz,
  83         RELOC **relocs, long *reloc_cnt,
  84         struct my_symtab **symtab_out, long *sym_cnt)
  85 {
  86         struct my_symtab *symt_o = NULL;
  87         char *stringtab = NULL;
  88         unsigned int base = 0;
  89         int text_scnum = 0;
  90         long filesize;
  91         char symname[9];
  92         long opthdr_pos;
  93         long reloc_size;
  94         FILHDR hdr;
  95         AOUTHDR opthdr;
  96         SCNHDR scnhdr;
  97         SYMENT syment;
  98         int i, s, val;
  99         int ret;
 100
 101         ret = fseek(f, 0, SEEK_END);
 102         my_assert(ret, 0);
 103
 104         filesize = ftell(f);
 105
 106         ret = fseek(f, 0, SEEK_SET);
 107         my_assert(ret, 0);
 108
 109         ret = fread(&hdr, 1, sizeof(hdr), f);
 110         my_assert(ret, sizeof(hdr));
 111
 112         if (hdr.f_magic == 0x5a4d) // MZ
 113         {
 114                 ret = fseek(f, 0x3c, SEEK_SET);
 115                 my_assert(ret, 0);
 116                 ret = fread(&val, 1, sizeof(val), f);
 117                 my_assert(ret, sizeof(val));
 118
 119                 ret = fseek(f, val, SEEK_SET);
 120                 my_assert(ret, 0);
 121                 ret = fread(&val, 1, sizeof(val), f);
 122                 my_assert(ret, sizeof(val));
 123                 my_assert(val, 0x4550); // PE
 124
 125                 // should be COFF now
 126                 ret = fread(&hdr, 1, sizeof(hdr), f);
 127                 my_assert(ret, sizeof(hdr));
 128         }
 129
 130         my_assert(hdr.f_magic, COFF_I386MAGIC);
 131
 132         if (hdr.f_opthdr != 0)
 133         {
 134                 opthdr_pos = ftell(f);
 135
 136                 if (hdr.f_opthdr < sizeof(opthdr))
 137                         my_assert(1, 0);
 138
 139                 ret = fread(&opthdr, 1, sizeof(opthdr), f);
 140                 my_assert(ret, sizeof(opthdr));
 141                 my_assert(opthdr.magic, COFF_ZMAGIC);
 142
 143                 printf("text_start: %x\n", opthdr.text_start);
 144
 145                 if (hdr.f_opthdr > sizeof(opthdr)) {
 146                         ret = fread(&base, 1, sizeof(base), f);
 147                         my_assert(ret, sizeof(base));
 148                         printf("base: %x\n", base);
 149                 }
 150                 ret = fseek(f, opthdr_pos + hdr.f_opthdr, SEEK_SET);
 151                 my_assert(ret, 0);
 152         }
 153
 154         // note: assuming first non-empty one is .text ..
 155         for (s = 0; s < hdr.f_nscns; s++) {
 156                 ret = fread(&scnhdr, 1, sizeof(scnhdr), f);
 157                 my_assert(ret, sizeof(scnhdr));
 158
 159                 if (scnhdr.s_size != 0) {
 160                         text_scnum = s + 1;
 161                         break;
 162                 }
 163         }
 164
 165         printf("f_nsyms:  %x\n", hdr.f_nsyms);
 166         printf("s_name:   '%s'\n", scnhdr.s_name);
 167         printf("s_vaddr:  %x\n", scnhdr.s_vaddr);
 168         printf("s_size:   %x\n", scnhdr.s_size);
 169         //printf("s_scnptr: %x\n", scnhdr.s_scnptr);
 170         printf("s_nreloc: %x\n", scnhdr.s_nreloc);
 171         printf("--\n");
 172
 173         ret = fseek(f, scnhdr.s_scnptr, SEEK_SET);
 174         my_assert(ret, 0);
 175
 176         *sect_data = malloc(scnhdr.s_size);
 177         my_assert_not(*sect_data, NULL);
 178         ret = fread(*sect_data, 1, scnhdr.s_size, f);
 179         my_assert(ret, scnhdr.s_size);
 180
 181         *sect_ofs = scnhdr.s_scnptr;
 182         *sect_sz = scnhdr.s_size;
 183
 184         // relocs
 185         ret = fseek(f, scnhdr.s_relptr, SEEK_SET);
 186         my_assert(ret, 0);
 187
 188         reloc_size = scnhdr.s_nreloc * sizeof((*relocs)[0]);
 189         *relocs = malloc(reloc_size + 1);
 190         my_assert_not(*relocs, NULL);
 191         ret = fread(*relocs, 1, reloc_size, f);
 192         my_assert(ret, reloc_size);
 193
 194         *reloc_cnt = scnhdr.s_nreloc;
 195
 196         // symtab
 197         if (hdr.f_nsyms != 0) {
 198                 symname[8] = 0;
 199
 200                 symt_o = malloc(hdr.f_nsyms * sizeof(symt_o[0]) + 1);
 201                 my_assert_not(symt_o, NULL);
 202
 203                 ret = fseek(f, hdr.f_symptr
 204                                 + hdr.f_nsyms * sizeof(syment), SEEK_SET);
 205                 my_assert(ret, 0);
 206                 ret = fread(&i, 1, sizeof(i), f);
 207                 my_assert(ret, sizeof(i));
 208                 my_assert((unsigned int)i < filesize, 1);
 209
 210                 stringtab = malloc(i);
 211                 my_assert_not(stringtab, NULL);
 212                 memset(stringtab, 0, 4);
 213                 ret = fread(stringtab + 4, 1, i - 4, f);
 214                 my_assert(ret, i - 4);
 215
 216                 ret = fseek(f, hdr.f_symptr, SEEK_SET);
 217                 my_assert(ret, 0);
 218         }
 219
 220         for (i = s = 0; i < hdr.f_nsyms; i++) {
 221                 long pos = ftell(f);
 222
 223                 ret = fread(&syment, 1, sizeof(syment), f);
 224                 my_assert(ret, sizeof(syment));
 225
 226                 strncpy(symname, syment.e.e_name, 8);
 227                 //printf("%3d %2d %08x '%s'\n", syment.e_sclass,
 228                 //      syment.e_scnum, syment.e_value, symname);
 229
 230                 if (syment.e_scnum != text_scnum || syment.e_sclass != C_EXT)
 231                         continue;
 232
 233                 symt_o[s].addr = syment.e_value;
 234                 symt_o[s].fpos = pos;
 235                 if (syment.e.e.e_zeroes == 0)
 236                         symt_o[s].name = stringtab + syment.e.e.e_offset;
 237                 else
 238                         symt_o[s].name = strdup(symname);
 239                 s++;
 240
 241                 if (syment.e_numaux) {
 242                         ret = fseek(f, syment.e_numaux * sizeof(syment),
 243                                     SEEK_CUR);
 244                         my_assert(ret, 0);
 245                         i += syment.e_numaux;
 246                 }
 247         }
 248
 249         if (symt_o != NULL)
 250                 qsort(symt_o, s, sizeof(symt_o[0]), symt_cmp);
 251
 252         *sym_cnt = s;
 253         *symtab_out = symt_o;
 254
 255         if (base != 0 && base_out != NULL)
 256                 *base_out = base + scnhdr.s_vaddr;
 257 }
 258
 259 static int handle_pad(uint8_t *d_obj, uint8_t *d_exe, int maxlen)
 260 {
 261         static const uint8_t p7[7] = { 0x8d, 0xa4, 0x24, 0x00, 0x00, 0x00, 0x00 };
 262         static const uint8_t p6[6] = { 0x8d, 0x9b, 0x00, 0x00, 0x00, 0x00 };
 263         static const uint8_t p5[5] = { 0x05, 0x00, 0x00, 0x00, 0x00 };
 264         static const uint8_t p4[4] = { 0x8d, 0x64, 0x24, 0x00 };
 265         static const uint8_t p3[3] = { 0x8d, 0x49, 0x00 };
 266         static const uint8_t p2[2] = { 0x8b, 0xff };
 267         static const uint8_t p1[1] = { 0x90 };
 268         int len;
 269         int i;
 270
 271         for (i = 0; i < maxlen; i++)
 272                 if (d_exe[i] != 0xcc)
 273                         break;
 274
 275         for (len = i; len > 0; )
 276         {
 277                 i = len;
 278                 if (i > 7)
 279                         i = 7;
 280
 281                 switch (i) {
 282                 #define CASE(x) \
 283                 case sizeof(p ## x): \
 284                         if (memcmp(d_obj, p ## x, sizeof(p ## x))) \
 285                                 return 0; \
 286                         memset(d_obj, 0xcc, sizeof(p ## x)); \
 287                         break;
 288                 CASE(7)
 289                 CASE(6)
 290                 CASE(5)
 291                 CASE(4)
 292                 CASE(3)
 293                 CASE(2)
 294                 CASE(1)
 295                 default:
 296                         printf("%s: unhandled len: %d\n", __func__, len);
 297                         return 0;
 298                 #undef CASE
 299                 }
 300
 301                 len -= i;
 302                 d_obj += i;
 303         }
 304
 305         return 1;
 306 }
 307
 308 struct equiv_opcode {
 309         signed char len;
 310         signed char ofs;
 311         short cmp_rm;
 312         uint8_t v_masm[8];
 313         uint8_t v_masm_mask[8];
 314         uint8_t v_msvc[8];
 315         uint8_t v_msvc_mask[8];
 316 } equiv_ops[] = {
 317         // cmp    $0x11,%ax
 318         { 4, -1, 0,
 319          { 0x66,0x83,0xf8,0x03 }, { 0xff,0xff,0xff,0x00 },
 320          { 0x66,0x3d,0x03,0x00 }, { 0xff,0xff,0x00,0xff }, },
 321         // lea    -0x1(%ebx,%eax,1),%esi // op mod/rm sib offs
 322         // mov, test, imm grp 1
 323         { 3, -2, 1,
 324          { 0x8d,0x74,0x03 }, { 0xf0,0x07,0xc0 },
 325          { 0x8d,0x74,0x18 }, { 0xf0,0x07,0xc0 }, },
 326         // movzbl 0x58f24a(%eax,%ecx,1),%eax
 327         { 4, -3, 1,
 328          { 0x0f,0xb6,0x84,0x08 }, { 0xff,0xff,0x07,0xc0 },
 329          { 0x0f,0xb6,0x84,0x01 }, { 0xff,0xff,0x07,0xc0 }, },
 330         // inc/dec
 331         { 3, -2, 1,
 332          { 0xfe,0x4c,0x03 }, { 0xfe,0xff,0xc0 },
 333          { 0xfe,0x4c,0x18 }, { 0xfe,0xff,0xc0 }, },
 334         // cmp
 335         { 3, -2, 1,
 336          { 0x38,0x0c,0x0c }, { 0xff,0xff,0xc0 },
 337          { 0x38,0x0c,0x30 }, { 0xff,0xff,0xc0 }, },
 338         // test   %dl,%bl
 339         { 2, -1, 1,
 340          { 0x84,0xd3 }, { 0xfe,0xc0 },
 341          { 0x84,0xda }, { 0xfe,0xc0 }, },
 342         // cmp    r,r/m vs rm/r
 343         { 2, 0, 1,
 344          { 0x3a,0xca }, { 0xff,0xc0 },
 345          { 0x38,0xd1 }, { 0xff,0xc0 }, },
 346         // rep + 66 prefix
 347         { 2, 0, 0,
 348          { 0xf3,0x66 }, { 0xfe,0xff },
 349          { 0x66,0xf3 }, { 0xff,0xfe }, },
 350         // fadd   st, st(0) vs st(0), st
 351         { 2, 0, 0,
 352          { 0xd8,0xc0 }, { 0xff,0xf7 },
 353          { 0xdc,0xc0 }, { 0xff,0xf7 }, },
 354
 355         // broad filters (may take too much..)
 356         // testb  $0x4,0x1d(%esi,%eax,1)
 357         // movb, push, ..
 358         { 3, -2, 1,
 359          { 0xf6,0x44,0x06 }, { 0x00,0x07,0xc0 },
 360          { 0xf6,0x44,0x30 }, { 0x00,0x07,0xc0 }, },
 361 };
 362
 363 static int cmp_mask(uint8_t *d, uint8_t *expect, uint8_t *mask, int len)
 364 {
 365         int i;
 366
 367         for (i = 0; i < len; i++)
 368                 if ((d[i] & mask[i]) != (expect[i] & mask[i]))
 369                         return 1;
 370
 371         return 0;
 372 }
 373
 374 static int check_equiv(uint8_t *d_obj, uint8_t *d_exe, int maxlen)
 375 {
 376         uint8_t vo, ve, vo2, ve2;
 377         int i, jo, je;
 378         int len, ofs;
 379
 380         for (i = 0; i < sizeof(equiv_ops) / sizeof(equiv_ops[0]); i++)
 381         {
 382                 struct equiv_opcode *op = &equiv_ops[i];
 383
 384                 len = op->len;
 385                 if (maxlen < len)
 386                         continue;
 387
 388                 ofs = op->ofs;
 389                 if (cmp_mask(d_obj + ofs, op->v_masm,
 390                              op->v_masm_mask, len))
 391                         continue;
 392                 if (cmp_mask(d_exe + ofs, op->v_msvc,
 393                              op->v_msvc_mask, len))
 394                         continue;
 395
 396                 jo = je = 0;
 397                 d_obj += ofs;
 398                 d_exe += ofs;
 399                 while (1)
 400                 {
 401                         for (; jo < len; jo++)
 402                                 if (op->v_masm_mask[jo] != 0xff)
 403                                         break;
 404                         for (; je < len; je++)
 405                                 if (op->v_msvc_mask[je] != 0xff)
 406                                         break;
 407
 408                         if ((jo == len && je != len) || (jo != len && je == len)) {
 409                                 printf("invalid equiv_ops\n");
 410                                 return -1;
 411                         }
 412                         if (jo == len)
 413                                 return len + ofs - 1; // matched
 414
 415                         // var byte
 416                         vo = d_obj[jo] & ~op->v_masm_mask[jo];
 417                         ve = d_exe[je] & ~op->v_msvc_mask[je];
 418                         if (op->cmp_rm && op->v_masm_mask[jo] == 0xc0) {
 419                                 vo2 = vo >> 3;
 420                                 vo &= 7;
 421                                 ve2 = ve & 7;
 422                                 ve >>= 3;
 423                                 if (vo != ve || vo2 != ve2)
 424                                         return -1;
 425                         }
 426                         else {
 427                                 if (vo != ve)
 428                                         return -1;
 429                         }
 430
 431                         jo++;
 432                         je++;
 433                 }
 434         }
 435
 436         return -1;
 437 }
 438
 439 int main(int argc, char *argv[])
 440 {
 441         FILE *f_obj, *f_exe;
 442         long text_ofs_obj, text_ofs_exe;
 443         long sztext_obj, sztext_exe, sztext_cmn;
 444         RELOC *relocs_obj, *relocs_exe;
 445         long reloc_cnt_obj, reloc_cnt_exe;
 446         struct my_symtab *syms_obj, *syms_exe;
 447         long sym_cnt_obj, sym_cnt_exe;
 448         uint8_t *d_obj, *d_exe;
 449         unsigned int base = 0;
 450         int retval = 1;
 451         int left;
 452         int ret;
 453         int i;
 454
 455         if (argc != 3) {
 456                 printf("usage:\n%s <a_obj> <exe>\n", argv[0]);
 457                 return 1;
 458         }
 459
 460         f_obj = fopen(argv[1], "r+b");
 461         if (f_obj == NULL) {
 462                 fprintf(stderr, "%s", argv[1]);
 463                 perror("");
 464                 return 1;
 465         }
 466
 467         f_exe = fopen(argv[2], "r");
 468         if (f_exe == NULL) {
 469                 fprintf(stderr, "%s", argv[2]);
 470                 perror("");
 471                 return 1;
 472         }
 473
 474         parse_headers(f_obj, NULL, &text_ofs_obj, &d_obj, &sztext_obj,
 475                 &relocs_obj, &reloc_cnt_obj, &syms_obj, &sym_cnt_obj);
 476         parse_headers(f_exe, &base, &text_ofs_exe, &d_exe, &sztext_exe,
 477                 &relocs_exe, &reloc_cnt_exe, &syms_exe, &sym_cnt_exe);
 478
 479         sztext_cmn = sztext_obj;
 480         if (sztext_cmn > sztext_exe)
 481                 sztext_cmn = sztext_exe;
 482
 483         if (sztext_cmn == 0) {
 484                 printf("bad .text size(s): %ld, %ld\n",
 485                         sztext_obj, sztext_exe);
 486                 return 1;
 487         }
 488
 489         for (i = 0; i < reloc_cnt_obj; i++)
 490         {
 491                 unsigned int a = relocs_obj[i].r_vaddr;
 492                 //printf("%04x %08x\n", relocs_obj[i].r_type, a);
 493
 494                 switch (relocs_obj[i].r_type) {
 495                 case 0x06:
 496                         memset(d_obj + a, 0, 4);
 497                         memset(d_exe + a, 0, 4);
 498                         break;
 499                 default:
 500                         printf("unknown reloc %x @%08x\n",
 501                                 relocs_obj[i].r_type, base + a);
 502                         return 1;
 503                 }
 504         }
 505
 506         for (i = 0; i < sztext_cmn; i++)
 507         {
 508                 if (d_obj[i] == d_exe[i])
 509                         continue;
 510
 511                 left = sztext_cmn - i;
 512
 513                 if (d_exe[i] == 0xcc) { // padding
 514                         if (handle_pad(d_obj + i, d_exe + i, left))
 515                                 continue;
 516                 }
 517
 518                 ret = check_equiv(d_obj + i, d_exe + i, left);
 519                 if (ret >= 0) {
 520                         i += ret;
 521                         continue;
 522                 }
 523
 524                 printf("%x: %02x vs %02x\n", base + i, d_obj[i], d_exe[i]);
 525                 goto out;
 526         }
 527
 528 out:
 529         return retval;
 530 }