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

/* Unexec for MIPS (including IRIS4D).
   Note that the GNU project considers support for MIPS operation
   a peripheral activity which should not be allowed to divert effort
   from development of the GNU system.  Changes in this code will be
   installed when users send them in, but aside from that
   we don't plan to think about it, or about whether other Emacs
   maintenance might break it.

   Copyright (C) 1988, 1994, 2001, 2002, 2003, 2004,
                 2005, 2006, 2007, 2008  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 3, 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., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.  */

\f
#include <config.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <stdio.h>
#include <varargs.h>

#ifdef MACH

#include <a.out.h>

/* I don't know why this isn't defined.  */
#ifndef STYP_INIT
#define STYP_INIT  0x80000000
#endif

/* I don't know why this isn't defined.  */
#ifndef _RDATA
#define	_RDATA	".rdata"
#define STYP_RDATA 0x00000100
#endif

/* Small ("near") data section.  */
#ifndef _SDATA
#define	_SDATA	".sdata"
#define STYP_SDATA 0x00000200
#endif

/* Small ("near") bss section.  */
#ifndef _SBSS
#define _SBSS ".sbss"
#define STYP_SBSS 0x00000400
#endif

/* We don't seem to have a sym.h or syms.h anywhere, so we'll do it the
   hard way.  This stinks.  */
typedef struct {
  short   magic;
  short   vstamp;
  long    ilineMax;
  struct { long foo, offset; } offsets[11];
} HDRR, *pHDRR;

#else /* not MACH */

#include <filehdr.h>
#include <aouthdr.h>
#include <scnhdr.h>
#include <sym.h>

#endif /* not MACH */

#if defined (IRIS_4D) || defined (sony)
#include "getpagesize.h"
#include <fcntl.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 ();
#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 *lit8_section;
static struct scnhdr *lit4_section;
static struct scnhdr *sdata_section;
static struct scnhdr *sbss_section;
static struct scnhdr *bss_section;

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

/* 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 data_start, bss_start, entry_address;
{
  int new, old;
  int pagesize, brk;
  int newsyms, symrel;
  int nread;
  struct headers hdr;
  int i;
  int vaddr, scnptr;
#define BUFSIZE 8192
  char buffer[BUFSIZE];

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

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

  hdr = *((struct headers *)TEXT_START);
  if (hdr.fhdr.f_magic != MIPSELMAGIC
      && hdr.fhdr.f_magic != MIPSEBMAGIC)
    {
      fprintf (stderr, "unexec: input file magic number is %x, not %x or %x.\n",
	       hdr.fhdr.f_magic, MIPSELMAGIC, MIPSEBMAGIC);
      exit (1);
    }
  if (hdr.fhdr.f_opthdr != sizeof (hdr.aout))
    {
      fprintf (stderr, "unexec: input a.out header is %d bytes, not %d.\n",
	       hdr.fhdr.f_opthdr, sizeof (hdr.aout));
      exit (1);
    }
  if (hdr.aout.magic != ZMAGIC)
    {
      fprintf (stderr, "unexec: input file a.out magic number is %o, not %o.\n",
	       hdr.aout.magic, ZMAGIC);
      exit (1);
    }

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

  CHECK_SCNHDR (text_section,  _TEXT,  STYP_TEXT);
  CHECK_SCNHDR (init_section,  _INIT,  STYP_INIT);
  CHECK_SCNHDR (rdata_section, _RDATA, STYP_RDATA);
  CHECK_SCNHDR (data_section,  _DATA,  STYP_DATA);
#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 != hdr.fhdr.f_nscns)
    fprintf (stderr, "unexec: %d sections found instead of %d.\n",
	     i, hdr.fhdr.f_nscns);
#endif

  text_section->s_scnptr = 0;

  pagesize = getpagesize ();
  /* Casting to int avoids compiler error on NEWS-OS 5.0.2.  */
  brk = (((int) (sbrk (0))) + pagesize - 1) & (-pagesize);
  hdr.aout.dsize = brk - DATA_START;
  hdr.aout.bsize = 0;
  if (entry_address == 0)
    {
      extern DEFAULT_ENTRY_ADDRESS ();
      hdr.aout.entry = (unsigned)DEFAULT_ENTRY_ADDRESS;
    }
  else
    hdr.aout.entry = entry_address;

  hdr.aout.bss_start = hdr.aout.data_start + hdr.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 + hdr.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;
    }
  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, hdr.aout.tsize,
	 "writing text section to %s", new_name);
  WRITE (new, (char *)DATA_START, hdr.aout.dsize,
	 "writing data section to %s", new_name);

  SEEK (old, hdr.fhdr.f_symptr, "seeking to start of symbols in %s", a_name);
  errno = EEOF;
  nread = read (old, buffer, BUFSIZE);
  if (nread < sizeof (HDRR)) fatal_unexec ("reading symbols from %s", a_name);
  newsyms = hdr.aout.tsize + hdr.aout.dsize;
  symrel = newsyms - hdr.fhdr.f_symptr;
  hdr.fhdr.f_symptr = newsyms;
#define symhdr ((pHDRR)buffer)
#ifdef MACH
  for (i = 0; i < 11; i++)
    symhdr->offsets[i].offset += symrel;
#else
  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;
#endif
#undef symhdr
  do
    {
      if (write (new, buffer, nread) != nread)
	fatal_unexec ("writing symbols to %s", new_name);
      nread = read (old, buffer, BUFSIZE);
      if (nread < 0) fatal_unexec ("reading symbols from %s", a_name);
#undef BUFSIZE
    } while (nread != 0);

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

  close (old);
  close (new);
  mark_x (new_name);
}
\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);
}

/* arch-tag: ebdd2058-3bbc-4de4-b5c7-5760379ab153
   (do not change this comment) */
Commit	Line	Data
9889c728 JB	1	/* Unexec for MIPS (including IRIS4D).
	2	Note that the GNU project considers support for MIPS operation
	3	a peripheral activity which should not be allowed to divert effort
	4	from development of the GNU system. Changes in this code will be
	5	installed when users send them in, but aside from that
	6	we don't plan to think about it, or about whether other Emacs
	7	maintenance might break it.
	8
429ab54e	9	Copyright (C) 1988, 1994, 2001, 2002, 2003, 2004,
8cabe764	10	2005, 2006, 2007, 2008 Free Software Foundation, Inc.
9889c728 JB	11
	12	This file is part of GNU Emacs.
	13
	14	GNU Emacs is free software; you can redistribute it and/or modify
	15	it under the terms of the GNU General Public License as published by
684d6f5b	16	the Free Software Foundation; either version 3, or (at your option)
9889c728 JB	17	any later version.
	18
	19	GNU Emacs is distributed in the hope that it will be useful,
	20	but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	GNU General Public License for more details.
	23
	24	You should have received a copy of the GNU General Public License
	25	along with GNU Emacs; see the file COPYING. If not, write to
4fc5845f LK	26	the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
4fc5845f LK	27	Boston, MA 02110-1301, USA. */
9889c728 JB	28
9889c728 JB	29	\f
18160b98	30	#include <config.h>
9889c728 JB	31	#include <sys/types.h>
	32	#include <sys/file.h>
	33	#include <sys/stat.h>
	34	#include <stdio.h>
	35	#include <varargs.h>
19ab8db9 RS	36
	37	#ifdef MACH
	38
	39	#include <a.out.h>
	40
	41	/* I don't know why this isn't defined. */
	42	#ifndef STYP_INIT
	43	#define STYP_INIT 0x80000000
	44	#endif
	45
	46	/* I don't know why this isn't defined. */
	47	#ifndef _RDATA
	48	#define _RDATA ".rdata"
	49	#define STYP_RDATA 0x00000100
	50	#endif
	51
	52	/* Small ("near") data section. */
	53	#ifndef _SDATA
	54	#define _SDATA ".sdata"
	55	#define STYP_SDATA 0x00000200
	56	#endif
	57
	58	/* Small ("near") bss section. */
	59	#ifndef _SBSS
	60	#define _SBSS ".sbss"
	61	#define STYP_SBSS 0x00000400
	62	#endif
	63
	64	/* We don't seem to have a sym.h or syms.h anywhere, so we'll do it the
	65	hard way. This stinks. */
	66	typedef struct {
	67	short magic;
	68	short vstamp;
	69	long ilineMax;
	70	struct { long foo, offset; } offsets[11];
	71	} HDRR, *pHDRR;
	72
	73	#else /* not MACH */
	74
9889c728 JB	75	#include <filehdr.h>
	76	#include <aouthdr.h>
	77	#include <scnhdr.h>
	78	#include <sym.h>
	79
19ab8db9 RS	80	#endif /* not MACH */
19ab8db9 RS	81
a36d8f29	82	#if defined (IRIS_4D) \|\| defined (sony)
9889c728	83	#include "getpagesize.h"
a36d8f29	84	#include <fcntl.h>
9889c728 JB	85	#endif
	86
	87	static void fatal_unexec ();
4fbc0284	88	static void mark_x ();
9889c728 JB	89
	90	#define READ(_fd, _buffer, _size, _error_message, _error_arg) \
	91	errno = EEOF; \
	92	if (read (_fd, _buffer, _size) != _size) \
	93	fatal_unexec (_error_message, _error_arg);
	94
	95	#define WRITE(_fd, _buffer, _size, _error_message, _error_arg) \
	96	if (write (_fd, _buffer, _size) != _size) \
	97	fatal_unexec (_error_message, _error_arg);
	98
	99	#define SEEK(_fd, _position, _error_message, _error_arg) \
	100	errno = EEOF; \
	101	if (lseek (_fd, _position, L_SET) != _position) \
	102	fatal_unexec (_error_message, _error_arg);
	103
	104	extern int errno;
20c92ac7	105	extern char *strerror ();
9889c728 JB	106	#define EEOF -1
	107
	108	static struct scnhdr *text_section;
	109	static struct scnhdr *init_section;
	110	static struct scnhdr *finit_section;
	111	static struct scnhdr *rdata_section;
	112	static struct scnhdr *data_section;
	113	static struct scnhdr *lit8_section;
	114	static struct scnhdr *lit4_section;
	115	static struct scnhdr *sdata_section;
	116	static struct scnhdr *sbss_section;
	117	static struct scnhdr *bss_section;
	118
	119	struct headers {
	120	struct filehdr fhdr;
	121	struct aouthdr aout;
	122	struct scnhdr section[10];
	123	};
	124
	125	/* Define name of label for entry point for the dumped executable. */
	126
	127	#ifndef DEFAULT_ENTRY_ADDRESS
	128	#define DEFAULT_ENTRY_ADDRESS __start
	129	#endif
	130	\f
	131	unexec (new_name, a_name, data_start, bss_start, entry_address)
	132	char new_name, a_name;
	133	unsigned data_start, bss_start, entry_address;
	134	{
	135	int new, old;
	136	int pagesize, brk;
	137	int newsyms, symrel;
	138	int nread;
	139	struct headers hdr;
	140	int i;
	141	int vaddr, scnptr;
	142	#define BUFSIZE 8192
	143	char buffer[BUFSIZE];
	144
	145	old = open (a_name, O_RDONLY, 0);
	146	if (old < 0) fatal_unexec ("opening %s", a_name);
	147
	148	new = creat (new_name, 0666);
	149	if (new < 0) fatal_unexec ("creating %s", new_name);
	150
	151	hdr = ((struct headers )TEXT_START);
9889c728 JB	152	if (hdr.fhdr.f_magic != MIPSELMAGIC
	153	&& hdr.fhdr.f_magic != MIPSEBMAGIC)
	154	{
	155	fprintf (stderr, "unexec: input file magic number is %x, not %x or %x.\n",
	156	hdr.fhdr.f_magic, MIPSELMAGIC, MIPSEBMAGIC);
	157	exit (1);
	158	}
9889c728 JB	159	if (hdr.fhdr.f_opthdr != sizeof (hdr.aout))
	160	{
	161	fprintf (stderr, "unexec: input a.out header is %d bytes, not %d.\n",
	162	hdr.fhdr.f_opthdr, sizeof (hdr.aout));
	163	exit (1);
	164	}
	165	if (hdr.aout.magic != ZMAGIC)
	166	{
	167	fprintf (stderr, "unexec: input file a.out magic number is %o, not %o.\n",
	168	hdr.aout.magic, ZMAGIC);
	169	exit (1);
	170	}
	171
	172	#define CHECK_SCNHDR(ptr, name, flags) \
248a26a7 RS	173	ptr = NULL; \
	174	for (i = 0; i < hdr.fhdr.f_nscns && !ptr; i++) \
	175	if (strcmp (hdr.section[i].s_name, name) == 0) \
	176	{ \
	177	if (hdr.section[i].s_flags != flags) \
	178	fprintf (stderr, "unexec: %x flags (%x expected) in %s section.\n", \
	179	hdr.section[i].s_flags, flags, name); \
	180	ptr = hdr.section + i; \
	181	} \
	182
9889c728 JB	183	CHECK_SCNHDR (text_section, _TEXT, STYP_TEXT);
	184	CHECK_SCNHDR (init_section, _INIT, STYP_INIT);
	185	CHECK_SCNHDR (rdata_section, _RDATA, STYP_RDATA);
	186	CHECK_SCNHDR (data_section, _DATA, STYP_DATA);
	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);
a36d8f29 RS	194	#if 0 /* Apparently this error check goes off on irix 3.3,
a36d8f29 RS	195	but it doesn't indicate a real problem. */
9889c728 JB	196	if (i != hdr.fhdr.f_nscns)
	197	fprintf (stderr, "unexec: %d sections found instead of %d.\n",
	198	i, hdr.fhdr.f_nscns);
a36d8f29 RS	199	#endif
	200
	201	text_section->s_scnptr = 0;
9889c728 JB	202
9889c728 JB	203	pagesize = getpagesize ();
817adff7 RS	204	/* Casting to int avoids compiler error on NEWS-OS 5.0.2. */
817adff7 RS	205	brk = (((int) (sbrk (0))) + pagesize - 1) & (-pagesize);
9889c728 JB	206	hdr.aout.dsize = brk - DATA_START;
	207	hdr.aout.bsize = 0;
	208	if (entry_address == 0)
	209	{
	210	extern DEFAULT_ENTRY_ADDRESS ();
	211	hdr.aout.entry = (unsigned)DEFAULT_ENTRY_ADDRESS;
	212	}
	213	else
	214	hdr.aout.entry = entry_address;
	215
	216	hdr.aout.bss_start = hdr.aout.data_start + hdr.aout.dsize;
	217	rdata_section->s_size = data_start - DATA_START;
248a26a7 RS	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 + hdr.aout.tsize;
	223
9889c728 JB	224	data_section->s_vaddr = data_start;
9889c728 JB	225	data_section->s_paddr = data_start;
c7663c14	226	data_section->s_size = brk - data_start;
9889c728 JB	227	data_section->s_scnptr = rdata_section->s_scnptr + rdata_section->s_size;
	228	vaddr = data_section->s_vaddr + data_section->s_size;
	229	scnptr = data_section->s_scnptr + data_section->s_size;
	230	if (lit8_section != NULL)
	231	{
	232	lit8_section->s_vaddr = vaddr;
	233	lit8_section->s_paddr = vaddr;
	234	lit8_section->s_size = 0;
	235	lit8_section->s_scnptr = scnptr;
	236	}
	237	if (lit4_section != NULL)
	238	{
	239	lit4_section->s_vaddr = vaddr;
	240	lit4_section->s_paddr = vaddr;
	241	lit4_section->s_size = 0;
	242	lit4_section->s_scnptr = scnptr;
	243	}
	244	if (sdata_section != NULL)
	245	{
	246	sdata_section->s_vaddr = vaddr;
	247	sdata_section->s_paddr = vaddr;
	248	sdata_section->s_size = 0;
	249	sdata_section->s_scnptr = scnptr;
	250	}
	251	if (sbss_section != NULL)
	252	{
	253	sbss_section->s_vaddr = vaddr;
	254	sbss_section->s_paddr = vaddr;
	255	sbss_section->s_size = 0;
	256	sbss_section->s_scnptr = scnptr;
	257	}
	258	if (bss_section != NULL)
	259	{
	260	bss_section->s_vaddr = vaddr;
	261	bss_section->s_paddr = vaddr;
	262	bss_section->s_size = 0;
	263	bss_section->s_scnptr = scnptr;
	264	}
	265
c6bfa947	266	WRITE (new, (char *)TEXT_START, hdr.aout.tsize,
9889c728	267	"writing text section to %s", new_name);
c6bfa947 KH	268	WRITE (new, (char *)DATA_START, hdr.aout.dsize,
c6bfa947 KH	269	"writing data section to %s", new_name);
9889c728 JB	270
	271	SEEK (old, hdr.fhdr.f_symptr, "seeking to start of symbols in %s", a_name);
	272	errno = EEOF;
	273	nread = read (old, buffer, BUFSIZE);
	274	if (nread < sizeof (HDRR)) fatal_unexec ("reading symbols from %s", a_name);
9889c728 JB	275	newsyms = hdr.aout.tsize + hdr.aout.dsize;
	276	symrel = newsyms - hdr.fhdr.f_symptr;
	277	hdr.fhdr.f_symptr = newsyms;
19ab8db9 RS	278	#define symhdr ((pHDRR)buffer)
	279	#ifdef MACH
	280	for (i = 0; i < 11; i++)
	281	symhdr->offsets[i].offset += symrel;
	282	#else
9889c728 JB	283	symhdr->cbLineOffset += symrel;
	284	symhdr->cbDnOffset += symrel;
	285	symhdr->cbPdOffset += symrel;
	286	symhdr->cbSymOffset += symrel;
	287	symhdr->cbOptOffset += symrel;
	288	symhdr->cbAuxOffset += symrel;
	289	symhdr->cbSsOffset += symrel;
	290	symhdr->cbSsExtOffset += symrel;
	291	symhdr->cbFdOffset += symrel;
	292	symhdr->cbRfdOffset += symrel;
	293	symhdr->cbExtOffset += symrel;
19ab8db9	294	#endif
9889c728 JB	295	#undef symhdr
	296	do
	297	{
	298	if (write (new, buffer, nread) != nread)
	299	fatal_unexec ("writing symbols to %s", new_name);
	300	nread = read (old, buffer, BUFSIZE);
	301	if (nread < 0) fatal_unexec ("reading symbols from %s", a_name);
	302	#undef BUFSIZE
	303	} while (nread != 0);
	304
	305	SEEK (new, 0, "seeking to start of header in %s", new_name);
	306	WRITE (new, &hdr, sizeof (hdr),
	307	"writing header of %s", new_name);
	308
	309	close (old);
	310	close (new);
	311	mark_x (new_name);
	312	}
	313	\f
	314	/*
	315	* mark_x
	316	*
eb8c3be9	317	* After successfully building the new a.out, mark it executable
9889c728 JB	318	*/
9889c728 JB	319
4fbc0284	320	static void
9889c728 JB	321	mark_x (name)
	322	char *name;
	323	{
	324	struct stat sbuf;
	325	int um = umask (777);
	326	umask (um);
	327	if (stat (name, &sbuf) < 0)
	328	fatal_unexec ("getting protection on %s", name);
	329	sbuf.st_mode \|= 0111 & ~um;
	330	if (chmod (name, sbuf.st_mode) < 0)
	331	fatal_unexec ("setting protection on %s", name);
	332	}
	333
	334	static void
	335	fatal_unexec (s, va_alist)
20c92ac7	336	va_dcl
9889c728 JB	337	{
	338	va_list ap;
	339	if (errno == EEOF)
	340	fputs ("unexec: unexpected end of file, ", stderr);
9889c728	341	else
20c92ac7	342	fprintf (stderr, "unexec: %s, ", strerror (errno));
9889c728 JB	343	va_start (ap);
	344	_doprnt (s, ap, stderr);
	345	fputs (".\n", stderr);
	346	exit (1);
	347	}
ab5796a9 MB	348
	349	/* arch-tag: ebdd2058-3bbc-4de4-b5c7-5760379ab153
	350	(do not change this comment) */