[bpt/emacs.git] / src / unexalpha.c

/* Unexec for DEC alpha.  schoepf@sc.ZIB-Berlin.DE (Rainer Schoepf).

   Copyright (C) 1994 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs 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, or (at your option)
any later version.

GNU Emacs 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 GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

\f
#include <config.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <stdio.h>
#include <varargs.h>
#include <filehdr.h>
#include <aouthdr.h>
#include <scnhdr.h>
#include <syms.h>

static void fatal_unexec ();
static void mark_x ();

#define READ(_fd, _buffer, _size, _error_message, _error_arg) \
	errno = EEOF; \
	if (read (_fd, _buffer, _size) != _size) \
	  fatal_unexec (_error_message, _error_arg);

#define WRITE(_fd, _buffer, _size, _error_message, _error_arg) \
	if (write (_fd, _buffer, _size) != _size) \
	  fatal_unexec (_error_message, _error_arg);

#define SEEK(_fd, _position, _error_message, _error_arg) \
	errno = EEOF; \
	if (lseek (_fd, _position, L_SET) != _position) \
	  fatal_unexec (_error_message, _error_arg);

extern int errno;
extern char *strerror ();

void *sbrk();

#define EEOF -1

static struct scnhdr *text_section;
static struct scnhdr *init_section;
static struct scnhdr *finit_section;
static struct scnhdr *rdata_section;
static struct scnhdr *rconst_section;
static struct scnhdr *data_section;
static struct scnhdr *pdata_section;
static struct scnhdr *xdata_section;
static struct scnhdr *got_section;
static struct scnhdr *lit8_section;
static struct scnhdr *lit4_section;
static struct scnhdr *sdata_section;
static struct scnhdr *sbss_section;
static struct scnhdr *bss_section;

static unsigned long Brk;

struct headers {
    struct filehdr fhdr;
    struct aouthdr aout;
    struct scnhdr section[_MIPS_NSCNS_MAX];
};


/* Define name of label for entry point for the dumped executable.  */

#ifndef DEFAULT_ENTRY_ADDRESS
#define DEFAULT_ENTRY_ADDRESS __start
#endif
\f
unexec (new_name, a_name, data_start, bss_start, entry_address)
     char *new_name, *a_name;
     unsigned long data_start, bss_start, entry_address;
{
  int new, old;
  char * oldptr;
  struct headers ohdr, nhdr;
  struct stat stat;
  long pagesize, brk;
  long newsyms, symrel;
  int nread;
  int i;
  long vaddr, scnptr;
#define BUFSIZE 8192
  char buffer[BUFSIZE];

  if ((old = open (a_name, O_RDONLY)) < 0)
    fatal_unexec ("opening %s", a_name);

  new = creat (new_name, 0666);
  if (new < 0) fatal_unexec ("creating %s", new_name);

  if ((fstat (old, &stat) == -1))
    fatal_unexec ("fstat %s", a_name);

  oldptr = (char *)mmap (0, stat.st_size, PROT_READ, MAP_FILE|MAP_SHARED, old, 0);

  if (oldptr == (char *)-1)
    fatal_unexec ("mmap %s", a_name);

  close (old);

  /* This is a copy of the a.out header of the original executable */

  ohdr = (*(struct headers *)oldptr);

  /* This is where we build the new header from the in-memory copy */

  nhdr = *((struct headers *)TEXT_START);

  /* First do some consistency checks */

  if (nhdr.fhdr.f_magic != ALPHAMAGIC
      && nhdr.fhdr.f_magic != ALPHAUMAGIC)
    {
      fprintf (stderr, "unexec: input file magic number is %x, not %x or %x.\n",
	       nhdr.fhdr.f_magic, ALPHAMAGIC, ALPHAUMAGIC);
      exit (1);
    }

  if (nhdr.fhdr.f_opthdr != sizeof (nhdr.aout))
    {
      fprintf (stderr, "unexec: input a.out header is %d bytes, not %d.\n",
	       nhdr.fhdr.f_opthdr, sizeof (nhdr.aout));
      exit (1);
    }
  if (nhdr.aout.magic != ZMAGIC)
    {
      fprintf (stderr, "unexec: input file a.out magic number is %o, not %o.\n",
	       nhdr.aout.magic, ZMAGIC);
      exit (1);
    }


  /* Now check the existence of certain header section and grab
     their addresses. */

#define CHECK_SCNHDR(ptr, name, flags)					\
  ptr = NULL;								\
  for (i = 0; i < nhdr.fhdr.f_nscns && !ptr; i++)			\
    if (strcmp (nhdr.section[i].s_name, name) == 0)			\
      {									\
	if (nhdr.section[i].s_flags != flags)				\
	  fprintf (stderr, "unexec: %x flags (%x expected) in %s section.\n", \
		   nhdr.section[i].s_flags, flags, name);		\
	ptr = nhdr.section + i;						\
      }									\

  CHECK_SCNHDR (text_section,  _TEXT,  STYP_TEXT);
  CHECK_SCNHDR (init_section,  _INIT,  STYP_INIT);
#ifdef _FINI
  CHECK_SCNHDR (finit_section, _FINI,  STYP_FINI);
#endif /* _FINI */
  CHECK_SCNHDR (rdata_section, _RDATA, STYP_RDATA);
#ifdef _RCONST
  CHECK_SCNHDR (rconst_section, _RCONST, STYP_RCONST);
#endif
#ifdef _PDATA
  CHECK_SCNHDR (pdata_section, _PDATA, STYP_PDATA);
#endif _PDATA
#ifdef _GOT
  CHECK_SCNHDR (got_section,   _GOT,   STYP_GOT);
#endif _GOT
  CHECK_SCNHDR (data_section,  _DATA,  STYP_DATA);
#ifdef _XDATA
  CHECK_SCNHDR (xdata_section, _XDATA, STYP_XDATA);
#endif /* _XDATA */
#ifdef _LIT8
  CHECK_SCNHDR (lit8_section,  _LIT8,  STYP_LIT8);
  CHECK_SCNHDR (lit4_section,  _LIT4,  STYP_LIT4);
#endif /* _LIT8 */
  CHECK_SCNHDR (sdata_section, _SDATA, STYP_SDATA);
  CHECK_SCNHDR (sbss_section,  _SBSS,  STYP_SBSS);
  CHECK_SCNHDR (bss_section,   _BSS,   STYP_BSS);


  pagesize = getpagesize ();
  brk = (((long) (sbrk (0))) + pagesize - 1) & (-pagesize);

  /* Remember the current break */

  Brk = brk;

  nhdr.aout.dsize = brk - DATA_START;
  nhdr.aout.bsize = 0;
  if (entry_address == 0)
    {
      extern DEFAULT_ENTRY_ADDRESS ();
      nhdr.aout.entry = (unsigned long)DEFAULT_ENTRY_ADDRESS;
    }
  else
    nhdr.aout.entry = entry_address;

  nhdr.aout.bss_start = nhdr.aout.data_start + nhdr.aout.dsize;

  if (rdata_section != NULL)
    {
      rdata_section->s_size = data_start - DATA_START;

      /* Adjust start and virtual addresses of rdata_section, too.  */
      rdata_section->s_vaddr = DATA_START;
      rdata_section->s_paddr = DATA_START;
      rdata_section->s_scnptr = text_section->s_scnptr + nhdr.aout.tsize;
    }

  data_section->s_vaddr = data_start;
  data_section->s_paddr = data_start;
  data_section->s_size = brk - data_start;

  if (rdata_section != NULL)
    {
      data_section->s_scnptr = rdata_section->s_scnptr + rdata_section->s_size;
    }

  vaddr = data_section->s_vaddr + data_section->s_size;
  scnptr = data_section->s_scnptr + data_section->s_size;
  if (lit8_section != NULL)
    {
      lit8_section->s_vaddr = vaddr;
      lit8_section->s_paddr = vaddr;
      lit8_section->s_size = 0;
      lit8_section->s_scnptr = scnptr;
    }
  if (lit4_section != NULL)
    {
      lit4_section->s_vaddr = vaddr;
      lit4_section->s_paddr = vaddr;
      lit4_section->s_size = 0;
      lit4_section->s_scnptr = scnptr;
    }
  if (sdata_section != NULL)
    {
      sdata_section->s_vaddr = vaddr;
      sdata_section->s_paddr = vaddr;
      sdata_section->s_size = 0;
      sdata_section->s_scnptr = scnptr;
    }
#ifdef _XDATA
  if (xdata_section != NULL)
    {
      xdata_section->s_vaddr = vaddr;
      xdata_section->s_paddr = vaddr;
      xdata_section->s_size = 0;
      xdata_section->s_scnptr = scnptr;
    }
#endif
#ifdef _GOT
  if (got_section != NULL)
    {
      bcopy (got_section, buffer, sizeof (struct scnhdr));

      got_section->s_vaddr = vaddr;
      got_section->s_paddr = vaddr;
      got_section->s_size = 0;
      got_section->s_scnptr = scnptr;
    }
#endif /*_GOT */
  if (sbss_section != NULL)
    {
      sbss_section->s_vaddr = vaddr;
      sbss_section->s_paddr = vaddr;
      sbss_section->s_size = 0;
      sbss_section->s_scnptr = scnptr;
    }
  if (bss_section != NULL)
    {
      bss_section->s_vaddr = vaddr;
      bss_section->s_paddr = vaddr;
      bss_section->s_size = 0;
      bss_section->s_scnptr = scnptr;
    }

  WRITE (new, (char *)TEXT_START, nhdr.aout.tsize,
	 "writing text section to %s", new_name);
  WRITE (new, (char *)DATA_START, nhdr.aout.dsize,
	 "writing data section to %s", new_name);

#ifdef _GOT
#define old_got_section ((struct scnhdr *)buffer)

  if (got_section != NULL)
    {
      SEEK (new, old_got_section->s_scnptr,
	    "seeking to start of got_section in %s", new_name);
      WRITE (new, oldptr + old_got_section->s_scnptr, old_got_section->s_size,
	     "writing new got_section of %s", new_name);
      SEEK (new, nhdr.aout.tsize + nhdr.aout.dsize,
	    "seeking to end of data section of %s", new_name);
    }

#undef old_got_section
#endif

  /*
   * Construct new symbol table header
   */

  bcopy (oldptr + nhdr.fhdr.f_symptr, buffer, cbHDRR);

#define symhdr ((pHDRR)buffer)
  newsyms = nhdr.aout.tsize + nhdr.aout.dsize;
  symrel = newsyms - nhdr.fhdr.f_symptr;
  nhdr.fhdr.f_symptr = newsyms;
  symhdr->cbLineOffset += symrel;
  symhdr->cbDnOffset += symrel;
  symhdr->cbPdOffset += symrel;
  symhdr->cbSymOffset += symrel;
  symhdr->cbOptOffset += symrel;
  symhdr->cbAuxOffset += symrel;
  symhdr->cbSsOffset += symrel;
  symhdr->cbSsExtOffset += symrel;
  symhdr->cbFdOffset += symrel;
  symhdr->cbRfdOffset += symrel;
  symhdr->cbExtOffset += symrel;

  WRITE (new, buffer, cbHDRR, "writing symbol table header of %s", new_name);

  /*
   * Copy the symbol table and line numbers
   */
  WRITE (new, oldptr + ohdr.fhdr.f_symptr + cbHDRR,
	 stat.st_size - ohdr.fhdr.f_symptr - cbHDRR,
	 "writing symbol table of %s", new_name);

#if 0

/* Not needed for now */

  update_dynamic_symbols (oldptr, new_name, new, newsyms,
			  ((pHDRR) (oldptr + ohdr.fhdr.f_symptr))->issExtMax,
                          ((pHDRR) (oldptr + ohdr.fhdr.f_symptr))->cbExtOffset,
                          ((pHDRR) (oldptr + ohdr.fhdr.f_symptr))->cbSsExtOffset);

#endif

#undef symhdr

  SEEK (new, 0, "seeking to start of header in %s", new_name);
  WRITE (new, &nhdr, sizeof (nhdr),
	 "writing header of %s", new_name);

  close (old);
  close (new);
  mark_x (new_name);
}


#if 0

/* Not needed for now */

/* The following function updates the values of some symbols
   that are used by the dynamic loader:

   _edata
   _end

*/


update_dynamic_symbols (old, new_name, new, newsyms, nsyms, symoff, stroff)
     char *old;			/* Pointer to old executable */
     char *new_name;            /* Name of new executable */
     int new;			/* File descriptor for new executable */
     long newsyms;		/* Offset of Symbol table in new executable */
     int nsyms;			/* Number of symbol table entries */
     long symoff;		/* Offset of External Symbols in old file */
     long stroff;		/* Offset of string table in old file */
{
  long i;
  int found = 0;
  EXTR n_end, n_edata;

  /* We go through the symbol table entries until we have found the two
     symbols. */

  /* cbEXTR is the size of an external symbol table entry */

  for (i = 0; i < nsyms && found < 2; i += cbEXTR)
    {
      register pEXTR x = (pEXTR) (old + symoff + i);
      char *s;
  
      s = old + stroff + x->asym.iss; /* name of the symbol */

      if (!strcmp(s,"_edata"))
	{
	  found++;
          bcopy (x, &n_edata, cbEXTR);
	  n_edata.asym.value = Brk;
	  SEEK (new, newsyms + cbHDRR + i,
		"seeking to symbol _edata in %s", new_name);
	  WRITE (new, &n_edata, cbEXTR,
		 "writing symbol table entry for _edata into %s", new_name);
	}
      else if (!strcmp(s,"_end"))
	{
	  found++;
          bcopy (x, &n_end, cbEXTR);
	  n_end.asym.value = Brk;
	  SEEK (new, newsyms + cbHDRR + i,
		"seeking to symbol _end in %s", new_name);
	  WRITE (new, &n_end, cbEXTR,
		 "writing symbol table entry for _end into %s", new_name);
	}
    }

}

#endif

\f
/*
 * mark_x
 *
 * After successfully building the new a.out, mark it executable
 */

static void
mark_x (name)
     char *name;
{
  struct stat sbuf;
  int um = umask (777);
  umask (um);
  if (stat (name, &sbuf) < 0)
    fatal_unexec ("getting protection on %s", name);
  sbuf.st_mode |= 0111 & ~um;
  if (chmod (name, sbuf.st_mode) < 0)
    fatal_unexec ("setting protection on %s", name);
}

static void
fatal_unexec (s, arg)
     char *s;
     char *arg;
{
  if (errno == EEOF)
    fputs ("unexec: unexpected end of file, ", stderr);
  else
    fprintf (stderr, "unexec: %s, ", strerror (errno));
  fprintf (stderr, s, arg);
  fputs (".\n", stderr);
  exit (1);
}
Commit	Line	Data
b061d5f1 RS	1	/* Unexec for DEC alpha. schoepf@sc.ZIB-Berlin.DE (Rainer Schoepf).
	2
	3	Copyright (C) 1994 Free Software Foundation, Inc.
	4
	5	This file is part of GNU Emacs.
	6
	7	GNU Emacs is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2, or (at your option)
	10	any later version.
	11
	12	GNU Emacs is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GNU Emacs; see the file COPYING. If not, write to
3b7ad313 EN	19	the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
3b7ad313 EN	20	Boston, MA 02111-1307, USA. */
b061d5f1 RS	21
	22	\f
	23	#include <config.h>
	24	#include <sys/types.h>
	25	#include <sys/file.h>
	26	#include <sys/stat.h>
	27	#include <sys/mman.h>
	28	#include <stdio.h>
	29	#include <varargs.h>
	30	#include <filehdr.h>
	31	#include <aouthdr.h>
	32	#include <scnhdr.h>
	33	#include <syms.h>
	34
	35	static void fatal_unexec ();
	36	static void mark_x ();
	37
	38	#define READ(_fd, _buffer, _size, _error_message, _error_arg) \
	39	errno = EEOF; \
	40	if (read (_fd, _buffer, _size) != _size) \
	41	fatal_unexec (_error_message, _error_arg);
	42
	43	#define WRITE(_fd, _buffer, _size, _error_message, _error_arg) \
	44	if (write (_fd, _buffer, _size) != _size) \
	45	fatal_unexec (_error_message, _error_arg);
	46
	47	#define SEEK(_fd, _position, _error_message, _error_arg) \
	48	errno = EEOF; \
	49	if (lseek (_fd, _position, L_SET) != _position) \
	50	fatal_unexec (_error_message, _error_arg);
	51
	52	extern int errno;
	53	extern char *strerror ();
	54
	55	void *sbrk();
	56
	57	#define EEOF -1
	58
	59	static struct scnhdr *text_section;
	60	static struct scnhdr *init_section;
	61	static struct scnhdr *finit_section;
	62	static struct scnhdr *rdata_section;
866fc66a	63	static struct scnhdr *rconst_section;
b061d5f1 RS	64	static struct scnhdr *data_section;
	65	static struct scnhdr *pdata_section;
	66	static struct scnhdr *xdata_section;
	67	static struct scnhdr *got_section;
	68	static struct scnhdr *lit8_section;
	69	static struct scnhdr *lit4_section;
	70	static struct scnhdr *sdata_section;
	71	static struct scnhdr *sbss_section;
	72	static struct scnhdr *bss_section;
	73
866fc66a	74	static unsigned long Brk;
b061d5f1 RS	75
	76	struct headers {
	77	struct filehdr fhdr;
	78	struct aouthdr aout;
	79	struct scnhdr section[_MIPS_NSCNS_MAX];
	80	};
	81
	82
	83
	84	/* Define name of label for entry point for the dumped executable. */
	85
	86	#ifndef DEFAULT_ENTRY_ADDRESS
	87	#define DEFAULT_ENTRY_ADDRESS __start
	88	#endif
	89	\f
	90	unexec (new_name, a_name, data_start, bss_start, entry_address)
	91	char new_name, a_name;
	92	unsigned long data_start, bss_start, entry_address;
	93	{
	94	int new, old;
	95	char * oldptr;
	96	struct headers ohdr, nhdr;
	97	struct stat stat;
	98	long pagesize, brk;
	99	long newsyms, symrel;
	100	int nread;
	101	int i;
	102	long vaddr, scnptr;
	103	#define BUFSIZE 8192
	104	char buffer[BUFSIZE];
	105
	106	if ((old = open (a_name, O_RDONLY)) < 0)
	107	fatal_unexec ("opening %s", a_name);
	108
	109	new = creat (new_name, 0666);
	110	if (new < 0) fatal_unexec ("creating %s", new_name);
	111
	112	if ((fstat (old, &stat) == -1))
	113	fatal_unexec ("fstat %s", a_name);
	114
	115	oldptr = (char *)mmap (0, stat.st_size, PROT_READ, MAP_FILE\|MAP_SHARED, old, 0);
	116
	117	if (oldptr == (char *)-1)
	118	fatal_unexec ("mmap %s", a_name);
	119
	120	close (old);
	121
	122	/* This is a copy of the a.out header of the original executable */
	123
	124	ohdr = ((struct headers )oldptr);
	125
	126	/* This is where we build the new header from the in-memory copy */
	127
	128	nhdr = ((struct headers )TEXT_START);
	129
	130	/* First do some consistency checks */
	131
	132	if (nhdr.fhdr.f_magic != ALPHAMAGIC
	133	&& nhdr.fhdr.f_magic != ALPHAUMAGIC)
	134	{
	135	fprintf (stderr, "unexec: input file magic number is %x, not %x or %x.\n",
	136	nhdr.fhdr.f_magic, ALPHAMAGIC, ALPHAUMAGIC);
	137	exit (1);
	138	}
139
140	if (nhdr.fhdr.f_opthdr != sizeof (nhdr.aout))
141	{
142	fprintf (stderr, "unexec: input a.out header is %d bytes, not %d.\n",
143	nhdr.fhdr.f_opthdr, sizeof (nhdr.aout));
144	exit (1);
145	}
146	if (nhdr.aout.magic != ZMAGIC)
147	{
148	fprintf (stderr, "unexec: input file a.out magic number is %o, not %o.\n",
149	nhdr.aout.magic, ZMAGIC);
150	exit (1);
151	}
152
153
154	/* Now check the existence of certain header section and grab
155	their addresses. */
156
157	#define CHECK_SCNHDR(ptr, name, flags) \
158	ptr = NULL; \
159	for (i = 0; i < nhdr.fhdr.f_nscns && !ptr; i++) \
160	if (strcmp (nhdr.section[i].s_name, name) == 0) \
161	{ \
162	if (nhdr.section[i].s_flags != flags) \
163	fprintf (stderr, "unexec: %x flags (%x expected) in %s section.\n", \
164	nhdr.section[i].s_flags, flags, name); \
165	ptr = nhdr.section + i; \
166	} \
167
168	CHECK_SCNHDR (text_section, _TEXT, STYP_TEXT);
169	CHECK_SCNHDR (init_section, _INIT, STYP_INIT);
170	#ifdef _FINI
171	CHECK_SCNHDR (finit_section, _FINI, STYP_FINI);
172	#endif /* _FINI */
173	CHECK_SCNHDR (rdata_section, _RDATA, STYP_RDATA);
866fc66a RS	174	#ifdef _RCONST
	175	CHECK_SCNHDR (rconst_section, _RCONST, STYP_RCONST);
	176	#endif
b061d5f1 RS	177	#ifdef _PDATA
	178	CHECK_SCNHDR (pdata_section, _PDATA, STYP_PDATA);
	179	#endif _PDATA
	180	#ifdef _GOT
	181	CHECK_SCNHDR (got_section, _GOT, STYP_GOT);
	182	#endif _GOT
	183	CHECK_SCNHDR (data_section, _DATA, STYP_DATA);
	184	#ifdef _XDATA
	185	CHECK_SCNHDR (xdata_section, _XDATA, STYP_XDATA);
	186	#endif /* _XDATA */
	187	#ifdef _LIT8
	188	CHECK_SCNHDR (lit8_section, _LIT8, STYP_LIT8);
	189	CHECK_SCNHDR (lit4_section, _LIT4, STYP_LIT4);
	190	#endif /* _LIT8 */
	191	CHECK_SCNHDR (sdata_section, _SDATA, STYP_SDATA);
	192	CHECK_SCNHDR (sbss_section, _SBSS, STYP_SBSS);
	193	CHECK_SCNHDR (bss_section, _BSS, STYP_BSS);
b061d5f1 RS	194
	195
	196	pagesize = getpagesize ();
	197	brk = (((long) (sbrk (0))) + pagesize - 1) & (-pagesize);
	198
	199	/* Remember the current break */
	200
	201	Brk = brk;
	202
	203	nhdr.aout.dsize = brk - DATA_START;
	204	nhdr.aout.bsize = 0;
	205	if (entry_address == 0)
	206	{
	207	extern DEFAULT_ENTRY_ADDRESS ();
	208	nhdr.aout.entry = (unsigned long)DEFAULT_ENTRY_ADDRESS;
	209	}
	210	else
	211	nhdr.aout.entry = entry_address;
	212
	213	nhdr.aout.bss_start = nhdr.aout.data_start + nhdr.aout.dsize;
b061d5f1	214
866fc66a RS	215	if (rdata_section != NULL)
	216	{
	217	rdata_section->s_size = data_start - DATA_START;
	218
	219	/* Adjust start and virtual addresses of rdata_section, too. */
	220	rdata_section->s_vaddr = DATA_START;
	221	rdata_section->s_paddr = DATA_START;
	222	rdata_section->s_scnptr = text_section->s_scnptr + nhdr.aout.tsize;
	223	}
b061d5f1 RS	224
	225	data_section->s_vaddr = data_start;
	226	data_section->s_paddr = data_start;
	227	data_section->s_size = brk - data_start;
866fc66a RS	228
	229	if (rdata_section != NULL)
	230	{
	231	data_section->s_scnptr = rdata_section->s_scnptr + rdata_section->s_size;
	232	}
	233
b061d5f1 RS	234	vaddr = data_section->s_vaddr + data_section->s_size;
	235	scnptr = data_section->s_scnptr + data_section->s_size;
	236	if (lit8_section != NULL)
	237	{
	238	lit8_section->s_vaddr = vaddr;
	239	lit8_section->s_paddr = vaddr;
	240	lit8_section->s_size = 0;
	241	lit8_section->s_scnptr = scnptr;
	242	}
	243	if (lit4_section != NULL)
	244	{
	245	lit4_section->s_vaddr = vaddr;
	246	lit4_section->s_paddr = vaddr;
	247	lit4_section->s_size = 0;
	248	lit4_section->s_scnptr = scnptr;
	249	}
	250	if (sdata_section != NULL)
	251	{
	252	sdata_section->s_vaddr = vaddr;
	253	sdata_section->s_paddr = vaddr;
	254	sdata_section->s_size = 0;
	255	sdata_section->s_scnptr = scnptr;
	256	}
	257	#ifdef _XDATA
	258	if (xdata_section != NULL)
	259	{
	260	xdata_section->s_vaddr = vaddr;
	261	xdata_section->s_paddr = vaddr;
	262	xdata_section->s_size = 0;
	263	xdata_section->s_scnptr = scnptr;
	264	}
	265	#endif
	266	#ifdef _GOT
	267	if (got_section != NULL)
	268	{
7d713448 RS	269	bcopy (got_section, buffer, sizeof (struct scnhdr));
7d713448 RS	270
b061d5f1 RS	271	got_section->s_vaddr = vaddr;
	272	got_section->s_paddr = vaddr;
	273	got_section->s_size = 0;
	274	got_section->s_scnptr = scnptr;
	275	}
	276	#endif /_GOT /
	277	if (sbss_section != NULL)
	278	{
	279	sbss_section->s_vaddr = vaddr;
	280	sbss_section->s_paddr = vaddr;
	281	sbss_section->s_size = 0;
	282	sbss_section->s_scnptr = scnptr;
	283	}
	284	if (bss_section != NULL)
	285	{
	286	bss_section->s_vaddr = vaddr;
	287	bss_section->s_paddr = vaddr;
	288	bss_section->s_size = 0;
	289	bss_section->s_scnptr = scnptr;
	290	}
	291
	292	WRITE (new, (char *)TEXT_START, nhdr.aout.tsize,
	293	"writing text section to %s", new_name);
	294	WRITE (new, (char *)DATA_START, nhdr.aout.dsize,
	295	"writing data section to %s", new_name);
	296
7d713448 RS	297	#ifdef _GOT
	298	#define old_got_section ((struct scnhdr *)buffer)
	299
	300	if (got_section != NULL)
	301	{
	302	SEEK (new, old_got_section->s_scnptr,
	303	"seeking to start of got_section in %s", new_name);
	304	WRITE (new, oldptr + old_got_section->s_scnptr, old_got_section->s_size,
	305	"writing new got_section of %s", new_name);
	306	SEEK (new, nhdr.aout.tsize + nhdr.aout.dsize,
	307	"seeking to end of data section of %s", new_name);
	308	}
	309
	310	#undef old_got_section
	311	#endif
b061d5f1 RS	312
	313	/*
	314	* Construct new symbol table header
	315	*/
	316
	317	bcopy (oldptr + nhdr.fhdr.f_symptr, buffer, cbHDRR);
	318
	319	#define symhdr ((pHDRR)buffer)
	320	newsyms = nhdr.aout.tsize + nhdr.aout.dsize;
	321	symrel = newsyms - nhdr.fhdr.f_symptr;
	322	nhdr.fhdr.f_symptr = newsyms;
	323	symhdr->cbLineOffset += symrel;
	324	symhdr->cbDnOffset += symrel;
	325	symhdr->cbPdOffset += symrel;
	326	symhdr->cbSymOffset += symrel;
	327	symhdr->cbOptOffset += symrel;
	328	symhdr->cbAuxOffset += symrel;
	329	symhdr->cbSsOffset += symrel;
	330	symhdr->cbSsExtOffset += symrel;
	331	symhdr->cbFdOffset += symrel;
	332	symhdr->cbRfdOffset += symrel;
	333	symhdr->cbExtOffset += symrel;
	334
	335	WRITE (new, buffer, cbHDRR, "writing symbol table header of %s", new_name);
	336
	337	/*
	338	* Copy the symbol table and line numbers
	339	*/
	340	WRITE (new, oldptr + ohdr.fhdr.f_symptr + cbHDRR,
	341	stat.st_size - ohdr.fhdr.f_symptr - cbHDRR,
	342	"writing symbol table of %s", new_name);
	343
	344	#if 0
	345
	346	/* Not needed for now */
	347
866fc66a	348	update_dynamic_symbols (oldptr, new_name, new, newsyms,
b061d5f1 RS	349	((pHDRR) (oldptr + ohdr.fhdr.f_symptr))->issExtMax,
	350	((pHDRR) (oldptr + ohdr.fhdr.f_symptr))->cbExtOffset,
	351	((pHDRR) (oldptr + ohdr.fhdr.f_symptr))->cbSsExtOffset);
	352
	353	#endif
	354
	355	#undef symhdr
	356
	357	SEEK (new, 0, "seeking to start of header in %s", new_name);
	358	WRITE (new, &nhdr, sizeof (nhdr),
	359	"writing header of %s", new_name);
	360
	361	close (old);
	362	close (new);
	363	mark_x (new_name);
	364	}
	365
	366
	367	#if 0
	368
	369	/* Not needed for now */
	370
	371	/* The following function updates the values of some symbols
	372	that are used by the dynamic loader:
	373
	374	_edata
	375	_end
	376
	377	*/
	378
	379
866fc66a RS	380	update_dynamic_symbols (old, new_name, new, newsyms, nsyms, symoff, stroff)
	381	char old; / Pointer to old executable */
	382	char new_name; / Name of new executable */
	383	int new; /* File descriptor for new executable */
	384	long newsyms; /* Offset of Symbol table in new executable */
	385	int nsyms; /* Number of symbol table entries */
	386	long symoff; /* Offset of External Symbols in old file */
	387	long stroff; /* Offset of string table in old file */
b061d5f1 RS	388	{
	389	long i;
	390	int found = 0;
	391	EXTR n_end, n_edata;
	392
	393	/* We go through the symbol table entries until we have found the two
	394	symbols. */
	395
	396	/* cbEXTR is the size of an external symbol table entry */
	397
	398	for (i = 0; i < nsyms && found < 2; i += cbEXTR)
	399	{
	400	register pEXTR x = (pEXTR) (old + symoff + i);
	401	char *s;
	402
	403	s = old + stroff + x->asym.iss; /* name of the symbol */
	404
	405	if (!strcmp(s,"_edata"))
	406	{
	407	found++;
	408	bcopy (x, &n_edata, cbEXTR);
	409	n_edata.asym.value = Brk;
	410	SEEK (new, newsyms + cbHDRR + i,
	411	"seeking to symbol _edata in %s", new_name);
866fc66a	412	WRITE (new, &n_edata, cbEXTR,
b061d5f1 RS	413	"writing symbol table entry for _edata into %s", new_name);
	414	}
	415	else if (!strcmp(s,"_end"))
	416	{
	417	found++;
	418	bcopy (x, &n_end, cbEXTR);
	419	n_end.asym.value = Brk;
	420	SEEK (new, newsyms + cbHDRR + i,
	421	"seeking to symbol _end in %s", new_name);
866fc66a	422	WRITE (new, &n_end, cbEXTR,
b061d5f1 RS	423	"writing symbol table entry for _end into %s", new_name);
	424	}
	425	}
	426
	427	}
	428
	429	#endif
	430
	431	\f
	432	/*
	433	* mark_x
	434	*
	435	* After successfully building the new a.out, mark it executable
	436	*/
	437
	438	static void
	439	mark_x (name)
	440	char *name;
	441	{
	442	struct stat sbuf;
	443	int um = umask (777);
	444	umask (um);
	445	if (stat (name, &sbuf) < 0)
	446	fatal_unexec ("getting protection on %s", name);
	447	sbuf.st_mode \|= 0111 & ~um;
	448	if (chmod (name, sbuf.st_mode) < 0)
	449	fatal_unexec ("setting protection on %s", name);
	450	}
	451
	452	static void
a084ed10 RS	453	fatal_unexec (s, arg)
	454	char *s;
	455	char *arg;
b061d5f1	456	{
b061d5f1 RS	457	if (errno == EEOF)
	458	fputs ("unexec: unexpected end of file, ", stderr);
	459	else
	460	fprintf (stderr, "unexec: %s, ", strerror (errno));
a084ed10	461	fprintf (stderr, s, arg);
b061d5f1 RS	462	fputs (".\n", stderr);
	463	exit (1);
	464	}