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