mac@rhea.mit.edu (Mike McNamara) (08/30/89)
Herein is a new m-titan.h, a new unextitan.c, and diffs to the files
process.c and loadst.c. Further there is a site-init.el, which
overrides paths.el's definiton of insert-man-page, as the titan
doesn't append a .Z to the catman files, even though they are compressed.
-----------------------------------------------------------------------------
For loadst.c:
On the titan, when you nlist into the kernel (to find
avenrun), it returns an address with high bits set, indicating this is
a supervisor address. When you seek on /dev/kmem, you need to turn off
these high address bits. Hence the following diff to loadst.c:
diff -cbr dist-18.55/etc/loadst.c wrk-18.55/etc/loadst.c
*** dist-18.55/etc/loadst.c Fri Aug 25 16:13:11 1989
--- wrk-18.55/etc/loadst.c Tue Aug 29 11:19:21 1989
***************
*** 159,164 ****
--- 159,167 ----
#endif /* not NLIST_STRUCT */
nlist (KERNEL_FILE, nl);
+ #ifdef titan
+ nl[0].n_value &= 0x1fffffff; /* titan uses high address bits to indicate priv/user*/
+ #endif /* titan */
#endif /* LOAD_AVE_TYPE */
while (--argc > 0)
-----------------------------------------------------------------------------
For process.c:
There are two fixes here.
The first one: The titan's file <sys/pty.h> needs to have
<sys/ttyhw.h> and <sys/stream.h> included also.
The second one:
This diff is only required if you compile at -O1 or higher.
If you compile at -g, the problem does not occur.
The compiler gets too eager and promots too much (or not
enough) code; in particular, it moves the test of wait_proc->flag&
PROC_STATUS against RUNNING out of the loop, WITHOUT testing if
wait_proc is 0. I have filed a bug report; however, it seems that the
c compiler backend is shared with the fortran compiler's backend, and
that the naive fix so that emacs compiles correctly at optimization causes
good, safe, optimizations to not be applied to fortran codes, and,
well, Ardent is in the parallel vectorizing fortran market, and the
Fortran customers pay the bills. But IMHO, bugs are bugs and the
compiler should be fixed; make it even smarter!
In the meantime, moving the entire test out of the loop by
hand ( it is, after all, a loop invarient test, and there is no need
to do it every time around the loop) allows gnu-emacs to be
compiled at optimization.
diff -cbr dist-18.55/src/process.c wrk-18.55/src/process.c
***************
*** 79,84 ****
--- 79,88 ----
#ifdef SYSV_PTYS
#include <sys/tty.h>
+ #ifdef titan
+ #include <sys/ttyhw.h>
+ #include <sys/stream.h>
+ #endif
#include <sys/pty.h>
#endif
***************
*** 1300,1305 ****
--- 1303,1309 ----
#endif /* not HAVE_TIMEVAL */
int Atemp;
int wait_channel = 0;
+ int tem;
struct Lisp_Process *wait_proc = 0;
extern kbd_count;
***************
*** 1324,1330 ****
end_time += time_limit;
#endif /* not HAVE_TIMEVAL */
}
!
while (1)
{
/* If calling from keyboard input, do not quit
--- 1328,1338 ----
end_time += time_limit;
#endif /* not HAVE_TIMEVAL */
}
! #ifdef titan
! /* Moved this code to avoid Ardent compiler bug. */
! tem = (wait_proc != 0 && (XFASTINT (wait_proc->flags) &
! PROC_STATUS) != RUNNING);
! #endif
while (1)
{
/* If calling from keyboard input, do not quit
***************
*** 1348,1357 ****
}
/* Don't wait for output from a non-running process. */
if (wait_proc != 0
&& (XFASTINT (wait_proc->flags) & PROC_STATUS) != RUNNING)
break;
!
if (fix_screen_hook)
(*fix_screen_hook) ();
--- 1356,1368 ----
}
/* Don't wait for output from a non-running process. */
+ #ifdef titan
+ if(tem) break;
+ #else
if (wait_proc != 0
&& (XFASTINT (wait_proc->flags) & PROC_STATUS) != RUNNING)
break;
! #endif
if (fix_screen_hook)
(*fix_screen_hook) ();
---lisp/site-init.el--------------------------------------------------------------------------
(defun insert-man-file (name)
;; Insert manual file (unpacked as necessary) into buffer
(call-process "zcat" name t nil))
---src/m-titan.h------------------------------------------------------------------------------
/* m- file for Ardent Titans.
Copyright (C) 1987 Free Software Foundation, Inc.
This file is part of GNU Emacs.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY. No author or distributor
accepts responsibility to anyone for the consequences of using it
or for whether it serves any particular purpose or works at all,
unless he says so in writing. Refer to the GNU Emacs General Public
License for full details.
Everyone is granted permission to copy, modify and redistribute
GNU Emacs, but only under the conditions described in the
GNU Emacs General Public License. A copy of this license is
supposed to have been given to you along with GNU Emacs so you
can know your rights and responsibilities. It should be in a
file named COPYING. Among other things, the copyright notice
and this notice must be preserved on all copies. */
/* The following three symbols give information on
the size of various data types. */
#define SHORTBITS 16 /* Number of bits in a short */
#define INTBITS 32 /* Number of bits in an int */
#define LONGBITS 32 /* Number of bits in a long */
/* Define BIG_ENDIAN iff lowest-numbered byte in a word
is the most significant byte. */
#define BIG_ENDIAN
/* Define NO_ARG_ARRAY if you cannot take the address of the first of a
* group of arguments and treat it as an array of the arguments. */
#define NO_ARG_ARRAY
/* Define WORD_MACHINE if addresses and such have
* to be corrected before they can be used as byte counts. */
#undef WORD_MACHINE
/* Define how to take a char and sign-extend into an int.
On machines where char is signed, this is a no-op. */
#define SIGN_EXTEND_CHAR(c) (c)
/* Now define a symbol for the cpu type, if your compiler
does not define it automatically:
Ones defined so far include vax, m68000, ns16000, pyramid,
orion, tahoe, APOLLO and many others */
#ifndef titan /* C compiler defines this */
# define titan
#endif
/* Use type int rather than a union, to represent Lisp_Object */
/* This is desirable for most machines. */
#define NO_UNION_TYPE
/* Define EXPLICIT_SIGN_EXTEND if XINT must explicitly sign-extend
the 24-bit bit field into an int. In other words, if bit fields
are always unsigned.
If you use NO_UNION_TYPE, this flag does not matter. */
#define EXPLICIT_SIGN_EXTEND
/* Data type of load average, as read out of kmem. */
#define LOAD_AVE_TYPE long
/* Convert that into an integer that is 100 for a load average of 1.0 */
#define LOAD_AVE_CVT(x) (int) (((double) (x)) * 100. / 65536.)
/* Define CANNOT_DUMP on machines where unexec does not work.
Then the function dump-emacs will not be defined
and temacs will do (load "loadup") automatically unless told otherwise. */
/* #define CANNOT_DUMP */
/* Define VIRT_ADDR_VARIES if the virtual addresses of
pure and impure space as loaded can vary, and even their
relative order cannot be relied on.
Otherwise Emacs assumes that text space precedes data space,
numerically. */
/* #define VIRT_ADDR_VARIES */
/* Define C_ALLOCA if this machine does not support a true alloca
and the one written in C should be used instead.
Define HAVE_ALLOCA to say that the system provides a properly
working alloca function and it should be used.
Define neither one if an assembler-language alloca
in the file alloca.s should be used. */
#define C_ALLOCA
/* #define HAVE_ALLOCA */
/* Define NO_REMAP if memory segmentation makes it not work well
to change the boundary between the text section and data section
when Emacs is dumped. If you define this, the preloaded Lisp
code will not be sharable; but that's better than failing completely. */
#define NO_REMAP
/*
* Define HAVE_TERMIO if the system provides sysV-style ioctls
* for terminal control.
*/
/* Ardent supports both termcap and terminfo; hence either define HAVE_TERMIO,
(gets you terminfo) or undefine it, (gets you termcap) as you wish. Note:
Ardent also supplies captoinfo, which translates from termcap to terminfo,
which lets you be even more terminal library independant. */
#define HAVE_TERMIO /* */
/* Give alloca some direction */
#define STACK_DIRECTION -1
/* undo various usg5-3 defines */
/* Unlike most SYSV's, Titan supports ^Z */
#ifdef NOMULTIPLEJOBS
#undef NOMULTIPLEJOBS
#endif /* */
/* Titan can support interrupt driven i/o; use it if you'd like to. */
/*
#ifndef INTERRUPT_INPUT
#define INTERRUPT_INPUT
#endif /* */
/* Titan supports timeval; x11term.c seems to need timeval, hence
I suggest you use it. */
#ifndef HAVE_TIMEVAL
#define HAVE_TIMEVAL
#endif /* */
/* Titan supports ptys */
#ifndef HAVE_PTYS
#define HAVE_PTYS
#define SYSV_PTYS
#endif /* */
/* Titan does NOT put networking library in libnsl_s.a; it's in libc */
#ifdef LIBX10_SYSTEM
#undef LIBX10_SYSTEM
#endif /* */
#ifdef LIBX11_SYSTEM
#undef LIBX11_SYSTEM
#endif /* */
/* ardent specific defines */
#define START_FILES /lib/crt0.o
#define C_OPTIMIZE_SWITCH -O1
#define C_SWITCH_MACHINE -I/usr/X11/include
#define LD_SWITCH_MACHINE
/* Unfortunatly, Ardent uses the name select in it's socklib library */
#define select(a,b,c,d,e) fake_select(a,b,c,d,e)
/* The titan only defines utimes in the BSD environment */
#define MISSING_UTIMES
/* setenv is a useful thing to have */
#define MAINTAIN_ENVIRONMENT
/* (loadst.c) Titan does not have this */
#undef DKSTAT_HEADER_FILE
/* RMS asked that I create an unextitan, as unexec.c has too many ifdefs already */
#define UNEXEC unextitan.o
#define TEXT_END _etext
#define DATA_END _edata
#define DATA_SECTION_ALIGNMENT pagemask
#define TEXT_START 0x400000
#ifdef __P3__ /* The new Titan P3 data section starts here */
#define DATA_START 0x10000000
#else /* The current titan P2 data section starts here */
#define DATA_START 0x10003000
#endif
#define DATA_SEG_BITS 0x10000000
/* -NW: titan cc performs lint; emacs is not lint free; -NW kills warnings */
#define C_DEBUG_SWITCH -O1 -NW
/* The standard definitions of these macros would work ok,
but these are faster because the constants are short. */
#define XUINT(a) (((unsigned)(a) << INTBITS-VALBITS) >> INTBITS-VALBITS)
#define XSET(var, type, ptr) \
((var) = ((int)(type) << VALBITS) + (((unsigned) (ptr) << INTBITS-VALBITS) >> INTBITS-VALBITS))
#define XSETINT(a, b) XSET(a, XTYPE(a), b)
#define XSETUINT(a, b) XSET(a, XTYPE(a), b)
#define XSETPNTR(a, b) XSET(a, XTYPE(a), b)
#define XMARKBIT(a) ((a) < 0)
/*(a < 0) returns 1, not MARKBIT, so XSETMARKBIT has to be redefined.*/
#define XSETMARKBIT(a,b) ((a) = ((b) ? (a)|MARKBIT : (a) & ~MARKBIT))
#define XUNMARK(a) ((a) = (((a) << INTBITS-GCTYPEBITS-VALBITS) >> INTBITS-GCTYPEBITS-VALBITS))
#define PURESIZE 200000
---src/unextitan.c--------------------------------------------------------------------------
/* Copyright (C) 1985, 1986, 1987, 1988 Free Software Foundation, Inc.
NO WARRANTY
BECAUSE THIS PROGRAM IS LICENSED FREE OF CHARGE, WE PROVIDE ABSOLUTELY
NO WARRANTY, TO THE EXTENT PERMITTED BY APPLICABLE STATE LAW. EXCEPT
WHEN OTHERWISE STATED IN WRITING, FREE SOFTWARE FOUNDATION, INC,
RICHARD M. STALLMAN AND/OR OTHER PARTIES PROVIDE THIS PROGRAM "AS IS"
WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY
AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
CORRECTION.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW WILL RICHARD M.
STALLMAN, THE FREE SOFTWARE FOUNDATION, INC., AND/OR ANY OTHER PARTY
WHO MAY MODIFY AND REDISTRIBUTE THIS PROGRAM AS PERMITTED BELOW, BE
LIABLE TO YOU FOR DAMAGES, INCLUDING ANY LOST PROFITS, LOST MONIES, OR
OTHER SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR
DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY THIRD PARTIES OR
A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS) THIS
PROGRAM, EVEN IF YOU HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY.
GENERAL PUBLIC LICENSE TO COPY
1. You may copy and distribute verbatim copies of this source file
as you receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy a valid copyright notice "Copyright
(C) 1987 Free Software Foundation, Inc."; and include following the
copyright notice a verbatim copy of the above disclaimer of warranty
and of this License. You may charge a distribution fee for the
physical act of transferring a copy.
2. You may modify your copy or copies of this source file or
any portion of it, and copy and distribute such modifications under
the terms of Paragraph 1 above, provided that you also do the following:
a) cause the modified files to carry prominent notices stating
that you changed the files and the date of any change; and
b) cause the whole of any work that you distribute or publish,
that in whole or in part contains or is a derivative of this
program or any part thereof, to be licensed at no charge to all
third parties on terms identical to those contained in this
License Agreement (except that you may choose to grant more extensive
warranty protection to some or all third parties, at your option).
c) You may charge a distribution fee for the physical act of
transferring a copy, and you may at your option offer warranty
protection in exchange for a fee.
Mere aggregation of another unrelated program with this program (or its
derivative) on a volume of a storage or distribution medium does not bring
the other program under the scope of these terms.
3. You may copy and distribute this program (or a portion or derivative
of it, under Paragraph 2) in object code or executable form under the terms
of Paragraphs 1 and 2 above provided that you also do one of the following:
a) accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of
Paragraphs 1 and 2 above; or,
b) accompany it with a written offer, valid for at least three
years, to give any third party free (except for a nominal
shipping charge) a complete machine-readable copy of the
corresponding source code, to be distributed under the terms of
Paragraphs 1 and 2 above; or,
c) accompany it with the information you received as to where the
corresponding source code may be obtained. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form alone.)
For an executable file, complete source code means all the source code for
all modules it contains; but, as a special exception, it need not include
source code for modules which are standard libraries that accompany the
operating system on which the executable file runs.
4. You may not copy, sublicense, distribute or transfer this program
except as expressly provided under this License Agreement. Any attempt
otherwise to copy, sublicense, distribute or transfer this program is void and
your rights to use the program under this License agreement shall be
automatically terminated. However, parties who have received computer
software programs from you with this License Agreement will not have
their licenses terminated so long as such parties remain in full compliance.
5. If you wish to incorporate parts of this program into other free
programs whose distribution conditions are different, write to the Free
Software Foundation at 675 Mass Ave, Cambridge, MA 02139. We have not yet
worked out a simple rule that can be stated here, but we will often permit
this. We will be guided by the two goals of preserving the free status of
all derivatives of our free software and of promoting the sharing and reuse of
software.
In other words, you are welcome to use, share and improve this program.
You are forbidden to forbid anyone else to use, share and improve
what you give them. Help stamp out software-hoarding! */
/*
* unexec.c - Convert a running program into an a.out file.
*
* Author: Spencer W. Thomas
* Computer Science Dept.
* University of Utah
* Date: Tue Mar 2 1982
* Modified heavily since then.
*
* Synopsis:
* unexec (new_name, a_name, data_start, bss_start, entry_address)
* char *new_name, *a_name;
* unsigned data_start, bss_start, entry_address;
*
* Takes a snapshot of the program and makes an a.out format file in the
* file named by the string argument new_name.
* If a_name is non-NULL, the symbol table will be taken from the given file.
* On some machines, an existing a_name file is required.
*
* The boundaries within the a.out file may be adjusted with the data_start
* and bss_start arguments. Either or both may be given as 0 for defaults.
*
* Data_start gives the boundary between the text segment and the data
* segment of the program. The text segment can contain shared, read-only
* program code and literal data, while the data segment is always unshared
* and unprotected. Data_start gives the lowest unprotected address.
* The value you specify may be rounded down to a suitable boundary
* as required by the machine you are using.
*
* Specifying zero for data_start means the boundary between text and data
* should not be the same as when the program was loaded.
* If NO_REMAP is defined, the argument data_start is ignored and the
* segment boundaries are never changed.
*
* Bss_start indicates how much of the data segment is to be saved in the
* a.out file and restored when the program is executed. It gives the lowest
* unsaved address, and is rounded up to a page boundary. The default when 0
* is given assumes that the entire data segment is to be stored, including
* the previous data and bss as well as any additional storage allocated with
* break (2).
*
* The new file is set up to start at entry_address.
*
* If you make improvements I'd like to get them too.
* harpo!utah-cs!thomas, thomas@Utah-20
*
*/
/* March 89 Michael McNamara (mac@ardent): finished Tim's port of unexec
* to the titan.
*/
/* There are several compilation parameters affecting unexec:
* COFF
Define this if your system uses COFF for executables.
Otherwise we assume you use Berkeley format.
* NO_REMAP
Define this if you do not want to try to save Emacs's pure data areas
as part of the text segment.
Saving them as text is good because it allows users to share more.
However, on machines that locate the text area far from the data area,
the boundary cannot feasibly be moved. Such machines require
NO_REMAP.
Also, remapping can cause trouble with the built-in startup routine
/lib/crt0.o, which defines `environ' as an initialized variable.
Dumping `environ' as pure does not work! So, to use remapping,
you must write a startup routine for your machine in Emacs's crt0.c.
If NO_REMAP is defined, Emacs uses the system's crt0.o.
* SECTION_ALIGNMENT
Some machines that use COFF executables require that each section
start on a certain boundary *in the COFF file*. Such machines should
define SECTION_ALIGNMENT to a mask of the low-order bits that must be
zero on such a boundary. This mask is used to control padding between
segments in the COFF file.
If SECTION_ALIGNMENT is not defined, the segments are written
consecutively with no attempt at alignment. This is right for
unmodified system V.
* SEGMENT_MASK
Some machines require that the beginnings and ends of segments
*in core* be on certain boundaries. For most machines, a page
boundary is sufficient. That is the default. When a larger
boundary is needed, define SEGMENT_MASK to a mask of
the bits that must be zero on such a boundary.
* A_TEXT_OFFSET(HDR)
Some machines count the a.out header as part of the size of the text
segment (a_text); they may actually load the header into core as the
first data in the text segment. Some have additional padding between
the header and the real text of the program that is counted in a_text.
For these machines, define A_TEXT_OFFSET(HDR) to examine the header
structure HDR and return the number of bytes to add to `a_text'
before writing it (above and beyond the number of bytes of actual
program text). HDR's standard fields are already correct, except that
this adjustment to the `a_text' field has not yet been made;
thus, the amount of offset can depend on the data in the file.
* A_TEXT_SEEK(HDR)
If defined, this macro specifies the number of bytes to seek into the
a.out file before starting to write the text segment.a
* EXEC_MAGIC
For machines using COFF, this macro, if defined, is a value stored
into the magic number field of the output file.
* ADJUST_EXEC_HEADER
This macro can be used to generate statements to adjust or
initialize nonstandard fields in the file header
* ADDR_CORRECT(ADDR)
Macro to correct an int which is the bit pattern of a pointer to a byte
into an int which is the number of a byte.
This macro has a default definition which is usually right.
This default definition is a no-op on most machines (where a
pointer looks like an int) but not on all machines.
*/
#ifndef emacs
#define PERROR(arg) perror (arg); return -1
#else
#include "config.h"
#define PERROR(file) report_error (file, new)
#endif
#ifndef CANNOT_DUMP /* all rest of file! */
#ifndef CANNOT_UNEXEC /* most of rest of file */
#include <a.out.h>
/* Define getpagesize () if the system does not.
Note that this may depend on symbols defined in a.out.h
*/
#include "getpagesize.h"
#ifndef makedev /* Try to detect types.h already loaded */
#include <sys/types.h>
#endif
#include <stdio.h>
#include <sys/stat.h>
#include <errno.h>
extern char *start_of_text (); /* Start of text */
extern char *start_of_data (); /* Start of initialized data */
static long block_copy_start; /* Old executable start point */
static struct filehdr f_hdr; /* File header */
static struct aouthdr f_ohdr; /* Optional file header (a.out) */
static struct scnhdr f_thdr; /* Text section header */
static struct scnhdr f_dhdr; /* Data section header */
static struct scnhdr f_shdr; /* Symtab section header */
static struct scnhdr f_bhdr; /* Bss section header */
static struct scnhdr f_ihdr; /* Ident section header */
static struct scnhdr scntemp; /* Temporary section header */
static long old_ident_scnptr;
long bias; /* Bias to add for growth */
long lnnoptr; /* Pointer to line-number info within file */
#define SYMS_START block_copy_start
static long text_scnptr;
static long data_scnptr;
static long symtab_scnptr;
static long ident_scnptr;
static long symptr_scnptr;
static int pagemask;
/* Correct an int which is the bit pattern of a pointer to a byte
into an int which is the number of a byte.
This is a no-op on ordinary machines, but not on all. */
#ifndef ADDR_CORRECT /* Let m-*.h files override this definition */
#define ADDR_CORRECT(x) ((char *)(x) - (char*)0)
#endif
#ifdef emacs
static
report_error (file, fd)
char *file;
int fd;
{
if (fd)
close (fd);
error ("Failure operating on %s", file);
}
#endif /* emacs */
#define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
#define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
#define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
static
report_error_1 (fd, msg, a1, a2)
int fd;
char *msg;
unsigned int a1, a2;
{
close (fd);
#ifdef emacs
error (msg, a1, a2);
#else
fprintf (stderr, msg, a1, a2);
fprintf (stderr, "\n");
#endif
}
/* ****************************************************************
* unexec
*
* driving logic.
*/
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 = -1;
int a_out = -1;
if (a_name && (a_out = open (a_name, 0)) < 0)
{
PERROR (a_name);
}
if ((new = creat (new_name, 0666)) < 0)
{
PERROR (new_name);
}
if (make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name) < 0
|| copy_text_and_data (new) < 0
|| copy_sym (new, a_out, a_name, new_name) < 0)
{
close (new);
/* unlink (new_name); /* Failed, unlink new a.out */
return -1;
}
close (new);
if (a_out >= 0)
close (a_out);
mark_x (new_name);
return 0;
}
/* ****************************************************************
* make_hdr
*
* Make the header in the new a.out from the header in core.
* Modify the text and data sizes.
*/
static int
make_hdr (new, a_out, data_start, bss_start, entry_address, a_name, new_name)
int new, a_out;
unsigned data_start, bss_start, entry_address;
char *a_name;
char *new_name;
{
register int scns;
unsigned int bss_end;
unsigned int start_next_section;
pagemask = getpagesize () - 1;
/* Adjust text/data boundary. */
#ifdef NO_REMAP
data_start = (int) start_of_data ();
#else /* not NO_REMAP */
if (!data_start)
data_start = (int) start_of_data ();
#endif /* not NO_REMAP */
data_start = ADDR_CORRECT (data_start);
#ifdef SEGMENT_MASK
data_start = data_start & ~SEGMENT_MASK; /* (Down) to segment boundary. */
#else
data_start = data_start & ~pagemask; /* (Down) to page boundary. */
#endif
bss_end = ADDR_CORRECT (sbrk (0)) + pagemask;
bss_end &= ~ pagemask;
/* Adjust data/bss boundary. */
if (bss_start != 0)
{
bss_start = (ADDR_CORRECT (bss_start) + pagemask);
/* (Up) to page bdry. */
bss_start &= ~ pagemask;
if (bss_start > bss_end)
{
ERROR1 ("unexec: Specified bss_start (%u) is past end of program",
bss_start);
}
}
else
bss_start = bss_end;
if (data_start > bss_start) /* Can't have negative data size. */
{
ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)",
data_start, bss_start);
}
/* Salvage as much info from the existing file as possible */
if (a_out >= 0)
{
if (read (a_out, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
{
PERROR (a_name);
}
block_copy_start += sizeof (f_hdr);
if (f_hdr.f_opthdr > 0)
{
if (read (a_out, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
{
PERROR (a_name);
}
block_copy_start += sizeof (f_ohdr);
}
/* Loop through section headers, copying them in */
for (scns = f_hdr.f_nscns; scns > 0; scns--) {
if (read (a_out, &scntemp, sizeof (scntemp)) != sizeof (scntemp))
{
PERROR (a_name);
}
if (scntemp.s_scnptr > 0L)
{
if (block_copy_start < scntemp.s_scnptr + scntemp.s_size)
block_copy_start = scntemp.s_scnptr + scntemp.s_size;
}
if (strcmp (scntemp.s_name, ".text") == 0)
{
f_thdr = scntemp;
}
else if (strcmp (scntemp.s_name, ".ident") == 0)
{
f_ihdr = scntemp;
}
else if (strcmp (scntemp.s_name, ".data") == 0)
{
f_dhdr = scntemp;
}
else if (strcmp (scntemp.s_name, ".bss") == 0)
{
f_bhdr = scntemp;
}
else if (strcmp (scntemp.s_name, ".symtab") == 0)
{
f_shdr = scntemp;
}
}
}
else
{
ERROR0 ("can't build a COFF file from scratch yet");
}
/* Now we alter the contents of all the f_*hdr variables
to correspond to what we want to dump. */
f_hdr.f_flags |= (
#ifndef titan
F_RELFLG |
#endif
F_EXEC);
#ifdef EXEC_MAGIC
f_ohdr.magic = EXEC_MAGIC;
#endif
#ifndef NO_REMAP
f_ohdr.text_start = (long) start_of_text ();
f_ohdr.tsize = data_start - f_ohdr.text_start;
f_ohdr.data_start = data_start;
#endif /* NO_REMAP */
f_ohdr.dsize = bss_start - f_ohdr.data_start;
f_ohdr.bsize = bss_end - bss_start;
#ifdef SECTION_ALIGNMENT
/* Some systems require special alignment
of the sections in the file itself. */
f_thdr.s_scnptr
= (f_thdr.s_scnptr + SECTION_ALIGNMENT) & ~SECTION_ALIGNMENT;
#endif /* SECTION_ALIGNMENT */
text_scnptr = f_thdr.s_scnptr;
f_dhdr.s_paddr = f_ohdr.data_start;
f_dhdr.s_vaddr = f_ohdr.data_start;
f_dhdr.s_size = f_ohdr.dsize;
f_dhdr.s_scnptr = f_thdr.s_scnptr + f_thdr.s_size;
#ifdef SECTION_ALIGNMENT
/* Some systems require special alignment
of the sections in the file itself. */
f_dhdr.s_scnptr
= (f_dhdr.s_scnptr + SECTION_ALIGNMENT) & ~SECTION_ALIGNMENT;
#endif /* SECTION_ALIGNMENT */
#ifdef DATA_SECTION_ALIGNMENT
/* Some systems require special alignment
of the data section only. */
f_dhdr.s_scnptr
= (f_dhdr.s_scnptr + DATA_SECTION_ALIGNMENT) & ~DATA_SECTION_ALIGNMENT;
#endif /* DATA_SECTION_ALIGNMENT */
data_scnptr = f_dhdr.s_scnptr;
f_bhdr.s_paddr = f_ohdr.data_start + f_ohdr.dsize;
f_bhdr.s_vaddr = f_ohdr.data_start + f_ohdr.dsize;
f_bhdr.s_size = f_ohdr.bsize;
f_bhdr.s_scnptr = 0L;
ident_scnptr = f_ihdr.s_scnptr;
if (f_ihdr.s_scnptr > 0L)
{
f_ihdr.s_scnptr = f_dhdr.s_scnptr + f_dhdr.s_size;
#ifdef DATA_SECTION_ALIGNMENT
f_ihdr.s_scnptr = (f_ihdr.s_scnptr + DATA_SECTION_ALIGNMENT)
& ~DATA_SECTION_ALIGNMENT;
#endif
start_next_section = f_ihdr.s_scnptr + f_ihdr.s_size;
}
symtab_scnptr = f_shdr.s_scnptr;
if (f_shdr.s_scnptr > 0L) /* symbol section */
{
f_shdr.s_scnptr = start_next_section;
start_next_section = f_shdr.s_scnptr + f_shdr.s_size;
}
symptr_scnptr = f_hdr.f_symptr;
if (f_hdr.f_symptr > 0L)
{
f_hdr.f_symptr = start_next_section;
}
#ifdef ADJUST_EXEC_HEADER
ADJUST_EXEC_HEADER
#endif /* ADJUST_EXEC_HEADER */
if (write (new, &f_hdr, sizeof (f_hdr)) != sizeof (f_hdr))
{
PERROR (new_name);
}
if (write (new, &f_ohdr, sizeof (f_ohdr)) != sizeof (f_ohdr))
{
PERROR (new_name);
}
if (write (new, &f_thdr, sizeof (f_thdr)) != sizeof (f_thdr))
{
PERROR (new_name);
}
if (write (new, &f_dhdr, sizeof (f_dhdr)) != sizeof (f_dhdr))
{
PERROR (new_name);
}
if (write (new, &f_ihdr, sizeof (f_ihdr)) != sizeof (f_ihdr))
{
PERROR (new_name);
}
if (write (new, &f_shdr, sizeof (f_shdr)) != sizeof (f_shdr))
{
PERROR (new_name);
}
return (0);
}
/* ****************************************************************
* copy_text_and_data
*
* Copy the text and data segments from memory to the new a.out
*/
static int
copy_text_and_data (new)
int new;
{
register char *end;
register char *ptr;
lseek (new, (long) text_scnptr, 0);
/* The titan stores its headers in the text segment. Also, we have to
avoid reading the floating point stuff, which is located at the
beginning of the data segment. */
ptr = (char *) f_thdr.s_vaddr;
end = ptr + f_thdr.s_size;
write_segment (new, ptr, end);
printf("copied text segment from [%x-%x] to xemacs\n", (int)ptr, (int)end);
lseek (new, (long) (data_scnptr + (DATA_START - f_ohdr.data_start)), 0);
printf("seeked to %x\n", (int)(data_scnptr + (DATA_START -
f_ohdr.data_start)));
ptr = (char *)DATA_START;
end = ptr + f_ohdr.dsize;
write_segment (new, ptr, end);
printf("copied data segment from [%x-%x] to xemacs\n", (int)ptr, (int)end);
return 0;
}
write_segment (new, ptr, end)
int new;
register char *ptr, *end;
{
register int i, nwrite, ret;
char buf[80];
extern int errno;
char zeros[128];
bzero (zeros, sizeof zeros);
for (i = 0; ptr < end;)
{
/* distance to next multiple of 128. */
nwrite = (((int) ptr + 128) & -128) - (int) ptr;
/* But not beyond specified end. */
if (nwrite > end - ptr) nwrite = end - ptr;
ret = write (new, ptr, nwrite);
/* If write gets a page fault, it means we reached
a gap between the old text segment and the old data segment.
This gap has probably been remapped into part of the text segment.
So write zeros for it. */
if (ret == -1 && errno == EFAULT)
write (new, zeros, nwrite);
else if (nwrite != ret)
{
sprintf (buf,
"unexec write failure: addr 0x%x, fileno %d, size 0x%x, wrote 0x%x, errno %d",
ptr, new, nwrite, ret, errno);
PERROR (buf);
}
i += nwrite;
ptr += nwrite;
}
}
/* ****************************************************************
* copy_sym
*
* Copy the relocation information and symbol table from the a.out to the new
*/
static int
copy_sym (new, a_out, a_name, new_name)
int new, a_out;
char *a_name, *new_name;
{
#define SIZE 8192
char page[SIZE];
int n,newsyms,symrel;
char * ptr;
char * end;
if (a_out < 0)
return 0;
if (SYMS_START == 0L)
return 0;
/* Copy .ident section */
if(ident_scnptr > 0)
{
lseek(a_out, ident_scnptr, 0);
printf( "seeking to 0x%x (start of .ident) in %s\n",
ident_scnptr,a_name);
lseek (new, (long) f_ihdr.s_scnptr, 0);
printf( "seeking to 0x%x (start of .ident) in %s\n",
f_ihdr.s_scnptr,new_name);
if ( (n = read(a_out, page, SIZE)) < 0)
PERROR("reading .ident section");
do
{
ptr = (char *) page;
end = ptr + n;
write_segment (new, ptr, end);
if( (n = read(a_out, page, SIZE)) < 0)
PERROR("reading .ident section");
} while (n != 0);
}
/* Copy symtab section */
if(symtab_scnptr > 0)
{
lseek(a_out, symtab_scnptr, 0);
printf( "seeking to 0x%x (start of .symtab) in %s\n",
symtab_scnptr,a_name);
lseek (new, (long) f_shdr.s_scnptr, 0);
printf( "seeking to 0x%x (start of .symtab) in %s\n",
f_shdr.s_scnptr,new_name);
if ( (n = read(a_out, page, SIZE)) < 0)
PERROR("reading .symtab section");
do
{
ptr = (char *) page;
end = ptr + n;
write_segment (new, ptr, end);
if( (n = read(a_out, page, SIZE)) < 0)
PERROR("reading .ident section");
} while (n != 0);
}
/* Copy & adjust symptr section */
if(symptr_scnptr>0)
{
lseek(a_out, symptr_scnptr, 0);
printf( "seeking to 0x%x (start of .symptr) in %s\n",
symptr_scnptr,a_name);
lseek (new, (long) f_hdr.f_symptr, 0);
printf( "seeking to 0x%x (start of .symptr) in %s\n",
f_hdr.f_symptr,new_name);
n = read(a_out, page, SIZE);
if (n < sizeof(SYMBOLS)) {
PERROR("reading symbols from temacs");
}
#define symhdr ((SYMBOLS *)page)
symrel = f_hdr.f_symptr - symptr_scnptr;
symhdr->strings_off += symrel;
if(symhdr->comini_off) /* If there is common initialized data...*/
symhdr->comini_off += symrel;
symhdr->address_off += symrel;
symhdr->symbols_off += symrel;
#undef symhdr
do
{
ptr = (char *) page;
end = ptr + n;
write_segment (new, ptr, end);
n = read(a_out, page, SIZE);
if (n < 0) {
PERROR("reading more symbols from temacs");
}
#undef SIZE
} while (n != 0);
}
return 0;
}
/* ****************************************************************
* mark_x
*
* After succesfully building the new a.out, mark it executable
*/
static
mark_x (name)
char *name;
{
struct stat sbuf;
int um;
int new = 0; /* for PERROR */
um = umask (777);
umask (um);
if (stat (name, &sbuf) == -1)
{
PERROR (name);
}
sbuf.st_mode |= 0111 & ~um;
if (chmod (name, sbuf.st_mode) == -1)
PERROR (name);
}
#endif /* not CANNOT_UNEXEC */
#endif /* not CANNOT_DUMP */
-----------------------------------------------------------------------------