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