git.chise.org Git - chise/xemacs-chise.git.1/blob - src/unexcw.c

   1 /* unexec for GNU Emacs on Cygwin32.
   2    Copyright (C) 1994, 1998 Free Software Foundation, Inc.
   3
   4 This file is part of XEmacs.
   5
   6 XEmacs is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 XEmacs is distributed in the hope that it will be useful, but WITHOUT
  12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with XEmacs; see the file COPYING.  If not, write to the Free
  18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.
  20
  21 */
  22
  23 /* This is a complete rewrite, some code snarfed from unexnt.c and
  24    unexec.c, Andy Piper (andy@xemacs.org) 13-1-98 */
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <config.h>
  31 #include <string.h>
  32
  33 #define DONT_ENCAPSULATE /* filenames are external in unex*.c */
  34 #include "sysfile.h"
  35
  36 #define PERROR(arg) perror(arg);exit(-1)
  37
  38 #ifndef HAVE_A_OUT_H
  39 unexec (char *, char *, void *, void *, void *)
  40 {
  41   PERROR("cannot unexec() a.out.h not installed");
  42 }
  43 #else
  44
  45 #ifndef MAX_PATH
  46 #define MAX_PATH 260
  47 #endif
  48 #include <a.out.h>
  49
  50 #define ALLOC_UNIT 0xFFFF
  51 #define ALLOC_MASK ~((unsigned long)(ALLOC_UNIT))
  52 #define ALIGN_ALLOC(addr) \
  53 ((((unsigned long)addr) + ALLOC_UNIT) & ALLOC_MASK)
  54 /* Note that all sections must be aligned on a 0x1000 boundary so
  55    this is the minimum size that our dummy bss can be. */
  56 #ifdef BROKEN_GDB
  57 #define BSS_PAD_SIZE    0x1000
  58 #else
  59 #define BSS_PAD_SIZE    0
  60 #endif
  61
  62 /* To prevent zero-initialized variables from being placed into the bss
  63    section, use non-zero values to represent an uninitialized state.  */
  64 #define UNINIT_PTR ((void *) 0xF0A0F0A0)
  65 #define UNINIT_LONG (0xF0A0F0A0L)
  66
  67 static void get_section_info (int a_out, char* a_name);
  68 static void copy_executable_and_dump_data_section (int a_out, int a_new);
  69 static void dup_file_area(int a_out, int a_new, long size);
  70 #if 0
  71 static void write_int_to_bss(int a_out, int a_new, void* va, void* newval);
  72 #endif
  73
  74 /* Cached info about the .data section in the executable.  */
  75 void* data_start_va = UNINIT_PTR;
  76 unsigned long  data_size = UNINIT_LONG;
  77
  78 /* Cached info about the .bss section in the executable.  */
  79 void* bss_start = UNINIT_PTR;
  80 unsigned long  bss_size = UNINIT_LONG;
  81 int sections_reversed = 0;
  82 FILHDR f_hdr;
  83 PEAOUTHDR f_ohdr;
  84 SCNHDR f_data, f_bss, f_text, f_nextdata;
  85
  86 #define PERROR(arg) perror(arg);exit(-1)
  87 #define CHECK_AOUT_POS(a) \
  88 if (lseek(a_out, 0, SEEK_CUR) != a) \
  89 { \
  90   printf("we are at %lx, should be at %lx\n", \
  91          lseek(a_out, 0, SEEK_CUR), a); \
  92   exit(-1); \
  93 }
  94
  95 void
  96 unexec (char *out_name, char *in_name, void *start_data,
  97         void * d1, void * d2);
  98 /* Dump out .data and .bss sections into a new executable.  */
  99 void unexec (char *out_name, char *in_name, void *start_data,
 100              void * d1, void * d2)
 101 {
 102   /* ugly nt hack - should be in lisp */
 103   int a_new, a_out = -1;
 104   char new_name[MAX_PATH], a_name[MAX_PATH];
 105   char *ptr;
 106
 107   /* Make sure that the input and output filenames have the
 108      ".exe" extension...patch them up if they don't.  */
 109   strcpy (a_name, in_name);
 110   ptr = a_name + strlen (a_name) - 4;
 111   if (strcmp (ptr, ".exe"))
 112     strcat (a_name, ".exe");
 113
 114   strcpy (new_name, out_name);
 115   ptr = new_name + strlen (new_name) - 4;
 116   if (strcmp (ptr, ".exe"))
 117     strcat (new_name, ".exe");
 118
 119   /* We need to round off our heap to NT's allocation unit (64KB).  */
 120   /* round_heap (get_allocation_unit ()); */
 121
 122   if (a_name && (a_out = open (a_name, O_RDONLY | OPEN_BINARY)) < 0)
 123     {
 124       PERROR (a_name);
 125     }
 126
 127   if ((a_new = open (new_name, O_WRONLY | O_TRUNC | O_CREAT | OPEN_BINARY,
 128                      0755)) < 0)
 129     {
 130       PERROR (new_name);
 131     }
 132
 133   /* Get the interesting section info, like start and size of .bss...  */
 134   get_section_info (a_out, a_name);
 135
 136   copy_executable_and_dump_data_section (a_out, a_new);
 137
 138   close(a_out);
 139   close(a_new);
 140 }
 141
 142 /* Flip through the executable and cache the info necessary for dumping.  */
 143 static void get_section_info (int a_out, char* a_name)
 144 {
 145   extern int my_ebss;
 146   /* From lastfile.c  */
 147   extern char my_edata[];
 148
 149   if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
 150     {
 151       PERROR (a_name);
 152     }
 153
 154   if (f_hdr.e_magic != DOSMAGIC)
 155     {
 156       PERROR("unknown exe header");
 157     }
 158
 159   /* Check the NT header signature ...  */
 160   if (f_hdr.nt_signature != NT_SIGNATURE)
 161     {
 162       PERROR("invalid nt header");
 163     }
 164
 165   /* Flip through the sections for .data and .bss ...  */
 166   if (f_hdr.f_opthdr > 0)
 167     {
 168       if (read (a_out, &f_ohdr, AOUTSZ) != AOUTSZ)
 169         {
 170           PERROR (a_name);
 171         }
 172     }
 173   /* Loop through .data & .bss section headers, copying them in.
 174      With newer lds these are reversed so we have to cope with both */
 175   lseek (a_out, sizeof (f_hdr) + f_hdr.f_opthdr, 0);
 176
 177   if (read (a_out, &f_text, sizeof (f_text)) != sizeof (f_text)
 178       ||
 179       strcmp (f_text.s_name, ".text"))
 180     {
 181       PERROR ("no .text section");
 182     }
 183
 184   /* The .bss section.  */
 185   if (read (a_out, &f_bss, sizeof (f_bss)) != sizeof (f_bss)
 186       ||
 187       (strcmp (f_bss.s_name, ".bss") && strcmp (f_bss.s_name, ".data")))
 188     {
 189       PERROR ("no .bss / .data section");
 190     }
 191
 192   /* check for reversed .bss and .data */
 193   if (!strcmp(f_bss.s_name, ".data"))
 194     {
 195       printf(".data and .bss reversed\n");
 196       sections_reversed = 1;
 197       memcpy(&f_data, &f_bss, sizeof(f_bss));
 198     }
 199
 200   /* The .data section.  */
 201   if (!sections_reversed)
 202     {
 203       if (read (a_out, &f_data, sizeof (f_data)) != sizeof (f_data)
 204           ||
 205           strcmp (f_data.s_name, ".data"))
 206         {
 207           PERROR ("no .data section");
 208         }
 209     }
 210   else
 211     {
 212       if (read (a_out, &f_bss, sizeof (f_bss)) != sizeof (f_bss)
 213           ||
 214           strcmp (f_bss.s_name, ".bss"))
 215         {
 216           PERROR ("no .bss section");
 217         }
 218     }
 219
 220   bss_start = (void *) ((char*)f_ohdr.ImageBase + f_bss.s_vaddr);
 221   bss_size = (unsigned long)((char*)&my_ebss-(char*)bss_start);
 222
 223   /* must keep bss data that we want to be blank as blank */
 224   printf("found bss - keeping %lx of %lx bytes\n", bss_size, f_ohdr.bsize);
 225
 226   /* The .data section.  */
 227   data_start_va = (void *) ((char*)f_ohdr.ImageBase + f_data.s_vaddr);
 228
 229   /* We want to only write Emacs data back to the executable,
 230      not any of the library data (if library data is included,
 231      then a dumped Emacs won't run on system versions other
 232      than the one Emacs was dumped on).  */
 233   data_size = (unsigned long)my_edata - (unsigned long)data_start_va;
 234   printf("found data - keeping %lx of %lx bytes\n", data_size, f_ohdr.dsize);
 235
 236   /* The following data section - often .idata */
 237   if (read (a_out, &f_nextdata, sizeof (f_nextdata)) != sizeof (f_nextdata)
 238       &&
 239       strcmp (&f_nextdata.s_name[2], "data"))
 240     {
 241       PERROR ("no other data section");
 242     }
 243 }
 244
 245 /* The dump routines.  */
 246
 247 static void
 248 copy_executable_and_dump_data_section (int a_out, int a_new)
 249 {
 250   long size=0;
 251   unsigned long new_data_size, new_bss_size,
 252     bss_padding, file_sz_change, data_padding=0,
 253     f_data_s_vaddr = f_data.s_vaddr,
 254     f_data_s_scnptr = f_data.s_scnptr,
 255     f_bss_s_vaddr = f_bss.s_vaddr,
 256     f_nextdata_s_scnptr = f_nextdata.s_scnptr;
 257
 258   int i;
 259   void* empty_space;
 260   extern int static_heap_dumped;
 261   SCNHDR section;
 262   /* calculate new sizes:
 263
 264      f_ohdr.dsize is the total initialized data size on disk which is
 265      f_data.s_size + f_idata.s_size.
 266
 267      f_ohdr.data_start is the base addres of all data and so should
 268      not be changed.
 269
 270      *.s_vaddr is the virtual address of the start of the section
 271      *normalized from f_ohdr.ImageBase.
 272
 273      *.s_paddr appears to be the number of bytes in the section
 274      *actually used (whereas *.s_size is aligned).
 275
 276      bsize is now 0 since subsumed into .data
 277      dsize is dsize + (f_data.s_vaddr - f_bss.s_vaddr)
 278      f_data.s_vaddr is f_bss.s_vaddr
 279      f_data.s_size is new dsize maybe.
 280      what about s_paddr & s_scnptr?  */
 281
 282   /* this is the amount the file increases in size */
 283   if (!sections_reversed)
 284     {
 285       new_bss_size = f_data.s_vaddr - f_bss.s_vaddr;
 286       data_padding = 0;
 287     }
 288   else
 289     {
 290       new_bss_size = f_nextdata.s_vaddr - f_bss.s_vaddr;
 291       data_padding = (f_bss.s_vaddr - f_data.s_vaddr) - f_data.s_size;
 292     }
 293
 294   file_sz_change=(new_bss_size + data_padding) - BSS_PAD_SIZE;
 295   new_data_size=f_ohdr.dsize + file_sz_change;
 296
 297   if (!sections_reversed)
 298     {
 299       f_data.s_vaddr = f_bss.s_vaddr;
 300     }
 301   f_data.s_paddr += file_sz_change;
 302 #if 0
 303   if (f_data.s_size + f_nextdata.s_size != f_ohdr.dsize)
 304     {
 305       printf("section size doesn't tally with dsize %lx != %lx\n",
 306              f_data.s_size + f_nextdata.s_size, f_ohdr.dsize);
 307     }
 308 #endif
 309   f_data.s_size += file_sz_change;
 310   lseek (a_new, 0, SEEK_SET);
 311   /* write file header */
 312   f_hdr.f_symptr += file_sz_change;
 313 #ifndef BROKEN_GDB
 314   f_hdr.f_nscns--;
 315 #endif
 316
 317   printf("writing file header\n");
 318   if (write(a_new, &f_hdr, sizeof(f_hdr)) != sizeof(f_hdr))
 319     {
 320       PERROR("failed to write file header");
 321     }
 322   /* write optional header fixing dsize & bsize*/
 323   printf("writing optional header\n");
 324   printf("new data size is %lx, >= %lx\n", new_data_size,
 325          f_ohdr.dsize + f_ohdr.bsize);
 326   if (new_data_size < f_ohdr.dsize + f_ohdr.bsize )
 327     {
 328       PERROR("new data size is < approx");
 329     }
 330   f_ohdr.dsize=new_data_size;
 331   f_ohdr.bsize=BSS_PAD_SIZE;
 332   if (write(a_new, &f_ohdr, sizeof(f_ohdr)) != sizeof(f_ohdr))
 333     {
 334       PERROR("failed to write optional header");
 335     }
 336   /* write text as is */
 337   printf("writing text header (unchanged)\n");
 338
 339   if (write(a_new, &f_text, sizeof(f_text)) != sizeof(f_text))
 340     {
 341       PERROR("failed to write text header");
 342     }
 343 #ifdef BROKEN_GDB
 344   /* Write small bss section. */
 345   if (!sections_reversed)
 346     {
 347       f_bss.s_size = BSS_PAD_SIZE;
 348       f_bss.s_paddr = BSS_PAD_SIZE;
 349       f_bss.s_vaddr = f_data.s_vaddr - BSS_PAD_SIZE;
 350       if (write(a_new, &f_bss, sizeof(f_bss)) != sizeof(f_bss))
 351         {
 352           PERROR("failed to write bss header");
 353         }
 354     }
 355 #endif
 356   /* write new data header */
 357   printf("writing .data header\n");
 358
 359   if (write(a_new, &f_data, sizeof(f_data)) != sizeof(f_data))
 360     {
 361       PERROR("failed to write data header");
 362     }
 363 #ifdef BROKEN_GDB
 364   /* Write small bss section. */
 365   if (sections_reversed)
 366     {
 367       f_bss.s_size = BSS_PAD_SIZE;
 368       f_bss.s_paddr = BSS_PAD_SIZE;
 369       f_bss.s_vaddr = f_nextdata.s_vaddr - BSS_PAD_SIZE;
 370       if (write(a_new, &f_bss, sizeof(f_bss)) != sizeof(f_bss))
 371         {
 372           PERROR("failed to write bss header");
 373         }
 374     }
 375 #endif
 376   printf("writing following data header\n");
 377   f_nextdata.s_scnptr += file_sz_change;
 378   if (f_nextdata.s_lnnoptr != 0) f_nextdata.s_lnnoptr += file_sz_change;
 379   if (f_nextdata.s_relptr != 0) f_nextdata.s_relptr += file_sz_change;
 380   if (write(a_new, &f_nextdata, sizeof(f_nextdata)) != sizeof(f_nextdata))
 381     {
 382       PERROR("failed to write nextdata header");
 383     }
 384
 385   /* copy other section headers adjusting the file offset */
 386   for (i=0; i<(f_hdr.f_nscns-3); i++)
 387     {
 388       if (read (a_out, &section, sizeof (section)) != sizeof (section))
 389         {
 390           PERROR ("no .data section");
 391         }
 392
 393       section.s_scnptr += file_sz_change;
 394       if (section.s_lnnoptr != 0) section.s_lnnoptr += file_sz_change;
 395       if (section.s_relptr != 0) section.s_relptr += file_sz_change;
 396
 397       if (write(a_new, &section, sizeof(section)) != sizeof(section))
 398         {
 399           PERROR("failed to write data header");
 400         }
 401     }
 402 #ifndef BROKEN_GDB
 403   /* dump bss to maintain offsets */
 404   memset(&f_bss, 0, sizeof(f_bss));
 405   if (write(a_new, &f_bss, sizeof(f_bss)) != sizeof(f_bss))
 406     {
 407       PERROR("failed to write bss header");
 408     }
 409 #endif
 410   size=lseek(a_new, 0, SEEK_CUR);
 411   CHECK_AOUT_POS(size);
 412
 413   /* copy eveything else until start of data */
 414   size = f_data_s_scnptr - lseek (a_out, 0, SEEK_CUR);
 415
 416   printf ("copying executable up to data section ... %lx bytes\n",
 417           size);
 418   dup_file_area(a_out, a_new, size);
 419
 420   CHECK_AOUT_POS(f_data_s_scnptr);
 421
 422   if (!sections_reversed)
 423     {
 424       /* dump bss + padding between sections, sans small bss pad */
 425       printf ("dumping .bss into executable... %lx bytes\n", bss_size);
 426       if (write(a_new, bss_start, bss_size) != (int)bss_size)
 427         {
 428           PERROR("failed to write bss section");
 429         }
 430
 431       /* pad, needs to be zero */
 432       bss_padding = (new_bss_size - bss_size) - BSS_PAD_SIZE;
 433       if (bss_padding < 0)
 434         {
 435           PERROR("padded .bss too small");
 436         }
 437       printf ("padding .bss ... %lx bytes\n", bss_padding);
 438       empty_space = malloc(bss_padding);
 439       memset(empty_space, 0, bss_padding);
 440       if (write(a_new, empty_space, bss_padding) != (int)bss_padding)
 441         {
 442           PERROR("failed to write bss section");
 443         }
 444       free(empty_space);
 445     }
 446
 447   /* tell dumped version not to free pure heap */
 448   static_heap_dumped = 1;
 449   /* Get a pointer to the raw data in our address space.  */
 450   printf ("dumping .data section... %lx bytes\n", data_size);
 451   if (write(a_new, data_start_va, data_size) != (int)data_size)
 452     {
 453       PERROR("failed to write data section");
 454     }
 455   /* were going to use free again ... */
 456   static_heap_dumped = 0;
 457
 458   size = lseek(a_out, f_data_s_scnptr + data_size, SEEK_SET);
 459
 460   if (!sections_reversed)
 461     {
 462       size = f_nextdata_s_scnptr - size;
 463       dup_file_area(a_out, a_new, size);
 464     }
 465   else
 466     {
 467       /* need to pad to bss with data in file */
 468       printf ("padding .data ... %lx bytes\n", data_padding);
 469       size = (f_bss_s_vaddr - f_data_s_vaddr) - data_size;
 470       dup_file_area(a_out, a_new, size);
 471
 472       /* dump bss + padding between sections */
 473       printf ("dumping .bss into executable... %lx bytes\n", bss_size);
 474       if (write(a_new, bss_start, bss_size) != (int)bss_size)
 475         {
 476           PERROR("failed to write bss section");
 477         }
 478
 479       /* pad, needs to be zero */
 480       bss_padding = (new_bss_size - bss_size) - BSS_PAD_SIZE;
 481       if (bss_padding < 0)
 482         {
 483           PERROR("padded .bss too small");
 484         }
 485       printf ("padding .bss ... %lx bytes\n", bss_padding);
 486       empty_space = malloc(bss_padding);
 487       memset(empty_space, 0, bss_padding);
 488       if (write(a_new, empty_space, bss_padding) != (int)bss_padding)
 489         {
 490           PERROR("failed to write bss section");
 491         }
 492       free(empty_space);
 493       if (lseek(a_new, 0, SEEK_CUR) != f_nextdata.s_scnptr)
 494         {
 495           printf("at %lx should be at %lx\n",
 496                  lseek(a_new, 0, SEEK_CUR),
 497                  f_nextdata.s_scnptr);
 498           PERROR("file positioning error\n");
 499         }
 500       lseek(a_out, f_nextdata_s_scnptr, SEEK_SET);
 501     }
 502
 503   CHECK_AOUT_POS(f_nextdata_s_scnptr);
 504
 505   /* now dump - nextdata don't need to do this cygwin ds is in .data! */
 506   printf ("dumping following data section... %lx bytes\n", f_nextdata.s_size);
 507
 508   dup_file_area(a_out,a_new,f_nextdata.s_size);
 509
 510   /* write rest of file */
 511   printf ("writing rest of file\n");
 512   size = lseek(a_out, 0, SEEK_END);
 513   size = size - (f_nextdata_s_scnptr + f_nextdata.s_size); /* length remaining in a_out */
 514   lseek(a_out, f_nextdata_s_scnptr + f_nextdata.s_size, SEEK_SET);
 515
 516   dup_file_area(a_out, a_new, size);
 517 }
 518
 519 /*
 520  * copy from aout to anew
 521  */
 522 static void dup_file_area(int a_out, int a_new, long size)
 523 {
 524   char page[BUFSIZ];
 525   long n;
 526   for (; size > 0; size -= sizeof (page))
 527     {
 528       n = size > sizeof (page) ? sizeof (page) : size;
 529       if (read (a_out, page, n) != n || write (a_new, page, n) != n)
 530         {
 531           PERROR ("dump_out()");
 532         }
 533     }
 534 }
 535
 536 #if 0
 537 static void write_int_to_bss(int a_out, int a_new, void* va, void* newval)
 538 {
 539   int cpos;
 540
 541   cpos = lseek(a_new, 0, SEEK_CUR);
 542   if (va < bss_start || va > bss_start + f_data.s_size)
 543     {
 544       PERROR("address not in data space\n");
 545     }
 546   lseek(a_new, f_data.s_scnptr + ((unsigned long)va -
 547                                   (unsigned long)bss_start), SEEK_SET);
 548   if (write(a_new, newval, sizeof(int)) != (int)sizeof(int))
 549     {
 550       PERROR("failed to write int value");
 551     }
 552   lseek(a_new, cpos, SEEK_SET);
 553 }
 554 #endif
 555
 556 #endif /* HAVE_A_OUT_H */