[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>
#ifndef __linux__
# include <reloc.h>
# include <elf_abi.h>
#endif

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 *rel_dyn_section;
static struct scnhdr *dynstr_section;
static struct scnhdr *dynsym_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 struct scnhdr old_data_scnhdr;

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 (strncmp (nhdr.section[i].s_name, name, 8) == 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 _REL_DYN
  CHECK_SCNHDR (rel_dyn_section, _REL_DYN,  STYP_REL_DYN);
#endif /* _REL_DYN */
#ifdef _DYNSYM
  CHECK_SCNHDR (dynsym_section, _DYNSYM,  STYP_DYNSYM);
#endif /* _REL_DYN */
#ifdef _DYNSTR
  CHECK_SCNHDR (dynstr_section, _DYNSTR,  STYP_DYNSTR);
#endif /* _REL_DYN */
#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;

  bcopy (data_section, &old_data_scnhdr, sizeof (old_data_scnhdr));

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

#ifndef __linux__
  update_dynamic_symbols (oldptr, new_name, new, nhdr.aout);
#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);
}


#ifndef __linux__

update_dynamic_symbols (old, new_name, new, aout)
     char *old;			/* Pointer to old executable */
     char *new_name;            /* Name of new executable */
     int new;			/* File descriptor for new executable */
     struct aouthdr aout;	/* a.out info from the file header */
{
  typedef struct dynrel_info {
    char * addr;
    unsigned type:8;
    unsigned index:24;
    unsigned info:8;
    unsigned pad:8;
  } dr_info;

  int nsyms = rel_dyn_section->s_size / sizeof (struct dynrel_info);
  int i;
  dr_info * rd_base = (dr_info *) (old + rel_dyn_section->s_scnptr);
  Elf32_Sym * ds_base = (Elf32_Sym *) (old + dynsym_section->s_scnptr);

  for (i = 0; i < nsyms; i++) {
    register Elf32_Sym x;

    if (rd_base[i].index == 0)
      continue;

    x = ds_base[rd_base[i].index];

#if 0
      fprintf (stderr, "Object inspected: %s, addr = %lx, shndx = %x",
	       old + dynstr_section->s_scnptr + x.st_name, rd_base[i].addr, x.st_shndx);
#endif


    if ((ELF32_ST_BIND (x.st_info) == STB_GLOBAL)
	&& (x.st_shndx == 0)
	/* && (x.st_value == NULL) */
	) {
      /* OK, this is probably a reference to an object in a shared
	 library, so copy the old value. This is done in several steps:
	 1. reladdr is the address of the location in question relative to
            the start of the data section,
         2. oldref is the addr is the mapped in temacs executable,
         3. newref is the address of the location in question in the
            undumped executable,
         4. len is the size of the object reference in bytes --
            currently only 4 (long) and 8 (quad) are supported.
	    */
      register unsigned long reladdr = rd_base[i].addr - old_data_scnhdr.s_vaddr;
      char * oldref = old + old_data_scnhdr.s_scnptr + reladdr;
      unsigned long newref = aout.tsize + reladdr;
      int len;

#if 0
      fprintf (stderr, "...relocated\n");
#endif

      if (rd_base[i].type == R_REFLONG) 
	len = 4;
      else if (rd_base[i].type == R_REFQUAD) 
	len = 8;
      else
	fatal_unexec ("unrecognized relocation type in .dyn.rel section (symbol #%d)", i);

      SEEK (new, newref, "seeking to dynamic symbol in %s", new_name);
      WRITE (new, oldref, len, "writing old dynrel info in %s", new_name);
    }

#if 0
    else
      fprintf (stderr, "...not relocated\n");
#endif

  }

}

#endif /* !__linux__ */

\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>
d7b43eaa RS	34	#ifndef __linux__
	35	# include <reloc.h>
	36	# include <elf_abi.h>
	37	#endif
b061d5f1 RS	38
	39	static void fatal_unexec ();
	40	static void mark_x ();
	41
	42	#define READ(_fd, _buffer, _size, _error_message, _error_arg) \
	43	errno = EEOF; \
	44	if (read (_fd, _buffer, _size) != _size) \
	45	fatal_unexec (_error_message, _error_arg);
	46
	47	#define WRITE(_fd, _buffer, _size, _error_message, _error_arg) \
	48	if (write (_fd, _buffer, _size) != _size) \
	49	fatal_unexec (_error_message, _error_arg);
	50
	51	#define SEEK(_fd, _position, _error_message, _error_arg) \
	52	errno = EEOF; \
	53	if (lseek (_fd, _position, L_SET) != _position) \
	54	fatal_unexec (_error_message, _error_arg);
	55
	56	extern int errno;
	57	extern char *strerror ();
	58
d7b43eaa	59	void *sbrk ();
b061d5f1 RS	60
	61	#define EEOF -1
	62
	63	static struct scnhdr *text_section;
d7b43eaa RS	64	static struct scnhdr *rel_dyn_section;
	65	static struct scnhdr *dynstr_section;
	66	static struct scnhdr *dynsym_section;
b061d5f1 RS	67	static struct scnhdr *init_section;
	68	static struct scnhdr *finit_section;
	69	static struct scnhdr *rdata_section;
866fc66a	70	static struct scnhdr *rconst_section;
b061d5f1 RS	71	static struct scnhdr *data_section;
	72	static struct scnhdr *pdata_section;
	73	static struct scnhdr *xdata_section;
	74	static struct scnhdr *got_section;
	75	static struct scnhdr *lit8_section;
	76	static struct scnhdr *lit4_section;
	77	static struct scnhdr *sdata_section;
	78	static struct scnhdr *sbss_section;
	79	static struct scnhdr *bss_section;
	80
d7b43eaa RS	81	static struct scnhdr old_data_scnhdr;
d7b43eaa RS	82
866fc66a	83	static unsigned long Brk;
b061d5f1 RS	84
	85	struct headers {
	86	struct filehdr fhdr;
	87	struct aouthdr aout;
	88	struct scnhdr section[_MIPS_NSCNS_MAX];
	89	};
	90
	91
	92
	93	/* Define name of label for entry point for the dumped executable. */
	94
	95	#ifndef DEFAULT_ENTRY_ADDRESS
	96	#define DEFAULT_ENTRY_ADDRESS __start
	97	#endif
	98	\f
	99	unexec (new_name, a_name, data_start, bss_start, entry_address)
	100	char new_name, a_name;
	101	unsigned long data_start, bss_start, entry_address;
	102	{
	103	int new, old;
	104	char * oldptr;
	105	struct headers ohdr, nhdr;
	106	struct stat stat;
	107	long pagesize, brk;
	108	long newsyms, symrel;
	109	int nread;
	110	int i;
	111	long vaddr, scnptr;
	112	#define BUFSIZE 8192
	113	char buffer[BUFSIZE];
	114
	115	if ((old = open (a_name, O_RDONLY)) < 0)
	116	fatal_unexec ("opening %s", a_name);
	117
	118	new = creat (new_name, 0666);
	119	if (new < 0) fatal_unexec ("creating %s", new_name);
	120
	121	if ((fstat (old, &stat) == -1))
	122	fatal_unexec ("fstat %s", a_name);
	123
	124	oldptr = (char *)mmap (0, stat.st_size, PROT_READ, MAP_FILE\|MAP_SHARED, old, 0);
	125
	126	if (oldptr == (char *)-1)
	127	fatal_unexec ("mmap %s", a_name);
	128
	129	close (old);
	130
	131	/* This is a copy of the a.out header of the original executable */
	132
	133	ohdr = ((struct headers )oldptr);
	134
	135	/* This is where we build the new header from the in-memory copy */
	136
	137	nhdr = ((struct headers )TEXT_START);
	138
	139	/* First do some consistency checks */
	140
	141	if (nhdr.fhdr.f_magic != ALPHAMAGIC
	142	&& nhdr.fhdr.f_magic != ALPHAUMAGIC)
	143	{
	144	fprintf (stderr, "unexec: input file magic number is %x, not %x or %x.\n",
	145	nhdr.fhdr.f_magic, ALPHAMAGIC, ALPHAUMAGIC);
	146	exit (1);
	147	}
148
149	if (nhdr.fhdr.f_opthdr != sizeof (nhdr.aout))
150	{
151	fprintf (stderr, "unexec: input a.out header is %d bytes, not %d.\n",
152	nhdr.fhdr.f_opthdr, sizeof (nhdr.aout));
153	exit (1);
154	}
155	if (nhdr.aout.magic != ZMAGIC)
156	{
157	fprintf (stderr, "unexec: input file a.out magic number is %o, not %o.\n",
158	nhdr.aout.magic, ZMAGIC);
159	exit (1);
160	}
161
162
163	/* Now check the existence of certain header section and grab
164	their addresses. */
165
166	#define CHECK_SCNHDR(ptr, name, flags) \
167	ptr = NULL; \
168	for (i = 0; i < nhdr.fhdr.f_nscns && !ptr; i++) \
d7b43eaa	169	if (strncmp (nhdr.section[i].s_name, name, 8) == 0) \
b061d5f1 RS	170	{ \
	171	if (nhdr.section[i].s_flags != flags) \
	172	fprintf (stderr, "unexec: %x flags (%x expected) in %s section.\n", \
	173	nhdr.section[i].s_flags, flags, name); \
	174	ptr = nhdr.section + i; \
	175	} \
	176
	177	CHECK_SCNHDR (text_section, _TEXT, STYP_TEXT);
	178	CHECK_SCNHDR (init_section, _INIT, STYP_INIT);
d7b43eaa RS	179	#ifdef _REL_DYN
	180	CHECK_SCNHDR (rel_dyn_section, _REL_DYN, STYP_REL_DYN);
	181	#endif /* _REL_DYN */
	182	#ifdef _DYNSYM
	183	CHECK_SCNHDR (dynsym_section, _DYNSYM, STYP_DYNSYM);
	184	#endif /* _REL_DYN */
	185	#ifdef _DYNSTR
	186	CHECK_SCNHDR (dynstr_section, _DYNSTR, STYP_DYNSTR);
	187	#endif /* _REL_DYN */
b061d5f1 RS	188	#ifdef _FINI
	189	CHECK_SCNHDR (finit_section, _FINI, STYP_FINI);
	190	#endif /* _FINI */
	191	CHECK_SCNHDR (rdata_section, _RDATA, STYP_RDATA);
866fc66a RS	192	#ifdef _RCONST
	193	CHECK_SCNHDR (rconst_section, _RCONST, STYP_RCONST);
	194	#endif
b061d5f1 RS	195	#ifdef _PDATA
	196	CHECK_SCNHDR (pdata_section, _PDATA, STYP_PDATA);
	197	#endif _PDATA
	198	#ifdef _GOT
	199	CHECK_SCNHDR (got_section, _GOT, STYP_GOT);
	200	#endif _GOT
	201	CHECK_SCNHDR (data_section, _DATA, STYP_DATA);
	202	#ifdef _XDATA
	203	CHECK_SCNHDR (xdata_section, _XDATA, STYP_XDATA);
	204	#endif /* _XDATA */
	205	#ifdef _LIT8
	206	CHECK_SCNHDR (lit8_section, _LIT8, STYP_LIT8);
	207	CHECK_SCNHDR (lit4_section, _LIT4, STYP_LIT4);
	208	#endif /* _LIT8 */
	209	CHECK_SCNHDR (sdata_section, _SDATA, STYP_SDATA);
	210	CHECK_SCNHDR (sbss_section, _SBSS, STYP_SBSS);
	211	CHECK_SCNHDR (bss_section, _BSS, STYP_BSS);
b061d5f1 RS	212
	213
	214	pagesize = getpagesize ();
	215	brk = (((long) (sbrk (0))) + pagesize - 1) & (-pagesize);
	216
	217	/* Remember the current break */
	218
	219	Brk = brk;
	220
d7b43eaa RS	221	bcopy (data_section, &old_data_scnhdr, sizeof (old_data_scnhdr));
d7b43eaa RS	222
b061d5f1 RS	223	nhdr.aout.dsize = brk - DATA_START;
	224	nhdr.aout.bsize = 0;
	225	if (entry_address == 0)
	226	{
	227	extern DEFAULT_ENTRY_ADDRESS ();
	228	nhdr.aout.entry = (unsigned long)DEFAULT_ENTRY_ADDRESS;
	229	}
	230	else
	231	nhdr.aout.entry = entry_address;
	232
	233	nhdr.aout.bss_start = nhdr.aout.data_start + nhdr.aout.dsize;
b061d5f1	234
866fc66a RS	235	if (rdata_section != NULL)
	236	{
	237	rdata_section->s_size = data_start - DATA_START;
	238
	239	/* Adjust start and virtual addresses of rdata_section, too. */
	240	rdata_section->s_vaddr = DATA_START;
	241	rdata_section->s_paddr = DATA_START;
	242	rdata_section->s_scnptr = text_section->s_scnptr + nhdr.aout.tsize;
	243	}
b061d5f1 RS	244
	245	data_section->s_vaddr = data_start;
	246	data_section->s_paddr = data_start;
	247	data_section->s_size = brk - data_start;
866fc66a RS	248
	249	if (rdata_section != NULL)
	250	{
	251	data_section->s_scnptr = rdata_section->s_scnptr + rdata_section->s_size;
	252	}
	253
b061d5f1 RS	254	vaddr = data_section->s_vaddr + data_section->s_size;
	255	scnptr = data_section->s_scnptr + data_section->s_size;
	256	if (lit8_section != NULL)
	257	{
	258	lit8_section->s_vaddr = vaddr;
	259	lit8_section->s_paddr = vaddr;
	260	lit8_section->s_size = 0;
	261	lit8_section->s_scnptr = scnptr;
	262	}
	263	if (lit4_section != NULL)
	264	{
	265	lit4_section->s_vaddr = vaddr;
	266	lit4_section->s_paddr = vaddr;
	267	lit4_section->s_size = 0;
	268	lit4_section->s_scnptr = scnptr;
	269	}
	270	if (sdata_section != NULL)
	271	{
	272	sdata_section->s_vaddr = vaddr;
	273	sdata_section->s_paddr = vaddr;
	274	sdata_section->s_size = 0;
	275	sdata_section->s_scnptr = scnptr;
	276	}
	277	#ifdef _XDATA
	278	if (xdata_section != NULL)
	279	{
	280	xdata_section->s_vaddr = vaddr;
	281	xdata_section->s_paddr = vaddr;
	282	xdata_section->s_size = 0;
	283	xdata_section->s_scnptr = scnptr;
	284	}
	285	#endif
	286	#ifdef _GOT
	287	if (got_section != NULL)
	288	{
7d713448 RS	289	bcopy (got_section, buffer, sizeof (struct scnhdr));
7d713448 RS	290
b061d5f1 RS	291	got_section->s_vaddr = vaddr;
	292	got_section->s_paddr = vaddr;
	293	got_section->s_size = 0;
	294	got_section->s_scnptr = scnptr;
	295	}
	296	#endif /_GOT /
	297	if (sbss_section != NULL)
	298	{
	299	sbss_section->s_vaddr = vaddr;
	300	sbss_section->s_paddr = vaddr;
	301	sbss_section->s_size = 0;
	302	sbss_section->s_scnptr = scnptr;
	303	}
	304	if (bss_section != NULL)
	305	{
	306	bss_section->s_vaddr = vaddr;
	307	bss_section->s_paddr = vaddr;
	308	bss_section->s_size = 0;
	309	bss_section->s_scnptr = scnptr;
	310	}
	311
	312	WRITE (new, (char *)TEXT_START, nhdr.aout.tsize,
	313	"writing text section to %s", new_name);
	314	WRITE (new, (char *)DATA_START, nhdr.aout.dsize,
	315	"writing data section to %s", new_name);
	316
7d713448 RS	317	#ifdef _GOT
	318	#define old_got_section ((struct scnhdr *)buffer)
	319
	320	if (got_section != NULL)
	321	{
	322	SEEK (new, old_got_section->s_scnptr,
	323	"seeking to start of got_section in %s", new_name);
	324	WRITE (new, oldptr + old_got_section->s_scnptr, old_got_section->s_size,
	325	"writing new got_section of %s", new_name);
	326	SEEK (new, nhdr.aout.tsize + nhdr.aout.dsize,
	327	"seeking to end of data section of %s", new_name);
	328	}
	329
	330	#undef old_got_section
	331	#endif
b061d5f1 RS	332
	333	/*
	334	* Construct new symbol table header
	335	*/
	336
	337	bcopy (oldptr + nhdr.fhdr.f_symptr, buffer, cbHDRR);
	338
	339	#define symhdr ((pHDRR)buffer)
	340	newsyms = nhdr.aout.tsize + nhdr.aout.dsize;
	341	symrel = newsyms - nhdr.fhdr.f_symptr;
	342	nhdr.fhdr.f_symptr = newsyms;
	343	symhdr->cbLineOffset += symrel;
	344	symhdr->cbDnOffset += symrel;
	345	symhdr->cbPdOffset += symrel;
	346	symhdr->cbSymOffset += symrel;
	347	symhdr->cbOptOffset += symrel;
	348	symhdr->cbAuxOffset += symrel;
	349	symhdr->cbSsOffset += symrel;
	350	symhdr->cbSsExtOffset += symrel;
	351	symhdr->cbFdOffset += symrel;
	352	symhdr->cbRfdOffset += symrel;
	353	symhdr->cbExtOffset += symrel;
	354
	355	WRITE (new, buffer, cbHDRR, "writing symbol table header of %s", new_name);
	356
	357	/*
	358	* Copy the symbol table and line numbers
	359	*/
	360	WRITE (new, oldptr + ohdr.fhdr.f_symptr + cbHDRR,
	361	stat.st_size - ohdr.fhdr.f_symptr - cbHDRR,
	362	"writing symbol table of %s", new_name);
	363
d7b43eaa RS	364	#ifndef __linux__
d7b43eaa RS	365	update_dynamic_symbols (oldptr, new_name, new, nhdr.aout);
b061d5f1 RS	366	#endif
	367
	368	#undef symhdr
	369
	370	SEEK (new, 0, "seeking to start of header in %s", new_name);
	371	WRITE (new, &nhdr, sizeof (nhdr),
	372	"writing header of %s", new_name);
	373
	374	close (old);
	375	close (new);
	376	mark_x (new_name);
	377	}
	378
	379
b061d5f1	380
b061d5f1	381
d7b43eaa	382	#ifndef __linux__
b061d5f1	383
d7b43eaa	384	update_dynamic_symbols (old, new_name, new, aout)
866fc66a RS	385	char old; / Pointer to old executable */
	386	char new_name; / Name of new executable */
	387	int new; /* File descriptor for new executable */
d7b43eaa	388	struct aouthdr aout; /* a.out info from the file header */
b061d5f1	389	{
d7b43eaa RS	390	typedef struct dynrel_info {
	391	char * addr;
	392	unsigned type:8;
	393	unsigned index:24;
	394	unsigned info:8;
	395	unsigned pad:8;
	396	} dr_info;
	397
	398	int nsyms = rel_dyn_section->s_size / sizeof (struct dynrel_info);
	399	int i;
	400	dr_info * rd_base = (dr_info *) (old + rel_dyn_section->s_scnptr);
	401	Elf32_Sym * ds_base = (Elf32_Sym *) (old + dynsym_section->s_scnptr);
b061d5f1	402
d7b43eaa RS	403	for (i = 0; i < nsyms; i++) {
d7b43eaa RS	404	register Elf32_Sym x;
b061d5f1	405
d7b43eaa RS	406	if (rd_base[i].index == 0)
d7b43eaa RS	407	continue;
b061d5f1	408
d7b43eaa RS	409	x = ds_base[rd_base[i].index];
	410
	411	#if 0
	412	fprintf (stderr, "Object inspected: %s, addr = %lx, shndx = %x",
	413	old + dynstr_section->s_scnptr + x.st_name, rd_base[i].addr, x.st_shndx);
	414	#endif
	415
	416
	417	if ((ELF32_ST_BIND (x.st_info) == STB_GLOBAL)
	418	&& (x.st_shndx == 0)
	419	/* && (x.st_value == NULL) */
	420	) {
	421	/* OK, this is probably a reference to an object in a shared
	422	library, so copy the old value. This is done in several steps:
	423	1. reladdr is the address of the location in question relative to
	424	the start of the data section,
	425	2. oldref is the addr is the mapped in temacs executable,
	426	3. newref is the address of the location in question in the
	427	undumped executable,
	428	4. len is the size of the object reference in bytes --
	429	currently only 4 (long) and 8 (quad) are supported.
	430	*/
	431	register unsigned long reladdr = rd_base[i].addr - old_data_scnhdr.s_vaddr;
	432	char * oldref = old + old_data_scnhdr.s_scnptr + reladdr;
	433	unsigned long newref = aout.tsize + reladdr;
	434	int len;
	435
	436	#if 0
	437	fprintf (stderr, "...relocated\n");
	438	#endif
	439
	440	if (rd_base[i].type == R_REFLONG)
	441	len = 4;
	442	else if (rd_base[i].type == R_REFQUAD)
	443	len = 8;
	444	else
	445	fatal_unexec ("unrecognized relocation type in .dyn.rel section (symbol #%d)", i);
	446
	447	SEEK (new, newref, "seeking to dynamic symbol in %s", new_name);
	448	WRITE (new, oldref, len, "writing old dynrel info in %s", new_name);
b061d5f1 RS	449	}
b061d5f1 RS	450
d7b43eaa RS	451	#if 0
	452	else
	453	fprintf (stderr, "...not relocated\n");
	454	#endif
	455
	456	}
	457
b061d5f1 RS	458	}
b061d5f1 RS	459
d7b43eaa	460	#endif /* !__linux__ */
b061d5f1 RS	461
	462	\f
	463	/*
	464	* mark_x
	465	*
	466	* After successfully building the new a.out, mark it executable
	467	*/
	468
	469	static void
	470	mark_x (name)
	471	char *name;
	472	{
	473	struct stat sbuf;
	474	int um = umask (777);
	475	umask (um);
	476	if (stat (name, &sbuf) < 0)
	477	fatal_unexec ("getting protection on %s", name);
	478	sbuf.st_mode \|= 0111 & ~um;
	479	if (chmod (name, sbuf.st_mode) < 0)
	480	fatal_unexec ("setting protection on %s", name);
	481	}
	482
	483	static void
a084ed10 RS	484	fatal_unexec (s, arg)
	485	char *s;
	486	char *arg;
b061d5f1	487	{
b061d5f1 RS	488	if (errno == EEOF)
	489	fputs ("unexec: unexpected end of file, ", stderr);
	490	else
	491	fprintf (stderr, "unexec: %s, ", strerror (errno));
a084ed10	492	fprintf (stderr, s, arg);
b061d5f1 RS	493	fputs (".\n", stderr);
	494	exit (1);
	495	}