[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, 675 Mass Ave, Cambridge, MA 02139, 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 *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 int 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 _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);
#if 0 /* Apparently this error check goes off on irix 3.3,
	 but it doesn't indicate a real problem.  */
  if (i != nhdr.fhdr.f_nscns)
    fprintf (stderr, "unexec: %d sections found instead of %d.\n",
	     i, nhdr.fhdr.f_nscns);
#endif


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


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