home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / e20313sr.zip / emacs / 20.3.1 / src / unexsni.c < prev    next >
Text File  |  1999-07-31  |  30KB  |  837 lines
  1. /* Unexec for Siemens machines running Sinix (modified SVR4).
  2.    Copyright (C) 1985, 1986, 1987, 1988, 1990, 1992, 1993, 1994, 1995
  3.    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. In other words, you are welcome to use, share and improve this program.
  23. You are forbidden to forbid anyone else to use, share and improve
  24. what you give them.   Help stamp out software-hoarding!  */
  25.  
  26.  
  27. /*
  28.  * unexec.c - Convert a running program into an a.out file.
  29.  *
  30.  * Author:    Spencer W. Thomas
  31.  *         Computer Science Dept.
  32.  *         University of Utah
  33.  * Date:    Tue Mar  2 1982
  34.  * Modified heavily since then.
  35.  *
  36.  * Synopsis:
  37.  *    unexec (new_name, a_name, data_start, bss_start, entry_address)
  38.  *    char *new_name, *a_name;
  39.  *    unsigned data_start, bss_start, entry_address;
  40.  *
  41.  * Takes a snapshot of the program and makes an a.out format file in the
  42.  * file named by the string argument new_name.
  43.  * If a_name is non-NULL, the symbol table will be taken from the given file.
  44.  * On some machines, an existing a_name file is required.
  45.  *
  46.  * The boundaries within the a.out file may be adjusted with the data_start
  47.  * and bss_start arguments.  Either or both may be given as 0 for defaults.
  48.  *
  49.  * Data_start gives the boundary between the text segment and the data
  50.  * segment of the program.  The text segment can contain shared, read-only
  51.  * program code and literal data, while the data segment is always unshared
  52.  * and unprotected.  Data_start gives the lowest unprotected address.
  53.  * The value you specify may be rounded down to a suitable boundary
  54.  * as required by the machine you are using.
  55.  *
  56.  * Specifying zero for data_start means the boundary between text and data
  57.  * should not be the same as when the program was loaded.
  58.  * If NO_REMAP is defined, the argument data_start is ignored and the
  59.  * segment boundaries are never changed.
  60.  *
  61.  * Bss_start indicates how much of the data segment is to be saved in the
  62.  * a.out file and restored when the program is executed.  It gives the lowest
  63.  * unsaved address, and is rounded up to a page boundary.  The default when 0
  64.  * is given assumes that the entire data segment is to be stored, including
  65.  * the previous data and bss as well as any additional storage allocated with
  66.  * break (2).
  67.  *
  68.  * The new file is set up to start at entry_address.
  69.  *
  70.  * If you make improvements I'd like to get them too.
  71.  * harpo!utah-cs!thomas, thomas@Utah-20
  72.  *
  73.  */
  74.  
  75. /* Even more heavily modified by james@bigtex.cactus.org of Dell Computer Co.
  76.  * ELF support added.
  77.  *
  78.  * Basic theory: the data space of the running process needs to be
  79.  * dumped to the output file.  Normally we would just enlarge the size
  80.  * of .data, scooting everything down.  But we can't do that in ELF,
  81.  * because there is often something between the .data space and the
  82.  * .bss space.
  83.  *
  84.  * In the temacs dump below, notice that the Global Offset Table
  85.  * (.got) and the Dynamic link data (.dynamic) come between .data1 and
  86.  * .bss.  It does not work to overlap .data with these fields.
  87.  *
  88.  * The solution is to create a new .data segment.  This segment is
  89.  * filled with data from the current process.  Since the contents of
  90.  * various sections refer to sections by index, the new .data segment
  91.  * is made the last in the table to avoid changing any existing index.
  92.  */
  93.  
  94. /* Modified by wtien@urbana.mcd.mot.com of Motorola Inc. 
  95.  * 
  96.  * The above mechanism does not work if the unexeced ELF file is being
  97.  * re-layout by other applications (such as `strip'). All the applications 
  98.  * that re-layout the internal of ELF will layout all sections in ascending
  99.  * order of their file offsets. After the re-layout, the data2 section will 
  100.  * still be the LAST section in the section header vector, but its file offset 
  101.  * is now being pushed far away down, and causes part of it not to be mapped
  102.  * in (ie. not covered by the load segment entry in PHDR vector), therefore 
  103.  * causes the new binary to fail.
  104.  *
  105.  * The solution is to modify the unexec algorithm to insert the new data2
  106.  * section header right before the new bss section header, so their file
  107.  * offsets will be in the ascending order. Since some of the section's (all 
  108.  * sections AFTER the bss section) indexes are now changed, we also need to 
  109.  * modify some fields to make them point to the right sections. This is done 
  110.  * by macro PATCH_INDEX. All the fields that need to be patched are:
  111.  * 
  112.  * 1. ELF header e_shstrndx field.
  113.  * 2. section header sh_link and sh_info field.
  114.  * 3. symbol table entry st_shndx field.
  115.  */
  116.  
  117. /*
  118.  * New modifications for Siemens Nixdorf's MIPS-based machines.
  119.  * Marco.Walther@mch.sni.de
  120.  *
  121.  * The problem: Before the bss segment we have a so called sbss segment
  122.  *              (small bss) and maybe an sdata segment. These segments
  123.  *              must also be handled correct.
  124.  *
  125.  * /home1/marco/emacs/emacs-19.22/src
  126.  * dump -hv temacs
  127.  * 
  128.  * temacs:
  129.  *
  130.  *       **** SECTION HEADER TABLE ****
  131.  * [No]    Type    Flags    Addr         Offset       Size            Name
  132.  *    Link    Info    Adralgn      Entsize
  133.  *
  134.  * [1]    PBIT    -A--    0x4000f4     0xf4         0x13             .interp
  135.  *    0    0    0x1          0            
  136.  *
  137.  * [2]    REGI    -A--    0x400108     0x108        0x18             .reginfo
  138.  *    0    0    0x4          0x18         
  139.  *
  140.  * [3]    DYNM    -A--    0x400120     0x120        0xb8             .dynamic
  141.  *    6    0    0x4          0x8          
  142.  *
  143.  * [4]    HASH    -A--    0x4001d8     0x1d8        0x8a0            .hash
  144.  *    5    0    0x4          0x4          
  145.  *
  146.  * [5]    DYNS    -A--    0x400a78     0xa78        0x11f0           .dynsym
  147.  *    6    2    0x4          0x10         
  148.  *
  149.  * [6]    STRT    -A--    0x401c68     0x1c68       0xbf9            .dynstr
  150.  *    0    0    0x1          0            
  151.  *
  152.  * [7]    REL     -A--    0x402864     0x2864       0x18             .rel.dyn
  153.  *    5    14    0x4          0x8          
  154.  *
  155.  * [8]    PBIT    -AI-    0x402880     0x2880       0x60             .init
  156.  *    0    0    0x10         0x1          
  157.  *
  158.  * [9]    PBIT    -AI-    0x4028e0     0x28e0       0x1234           .plt
  159.  *    0    0    0x4          0x4          
  160.  *
  161.  * [10]    PBIT    -AI-    0x403b20     0x3b20       0xee400          .text
  162.  *    0    0    0x20         0x1          
  163.  *
  164.  * [11]    PBIT    -AI-    0x4f1f20     0xf1f20      0x60             .fini
  165.  *    0    0    0x10         0x1          
  166.  *
  167.  * [12]    PBIT    -A--    0x4f1f80     0xf1f80      0xd90            .rdata
  168.  *    0    0    0x10         0x1          
  169.  *
  170.  * [13]    PBIT    -A--    0x4f2d10     0xf2d10      0x17e0           .rodata
  171.  *    0    0    0x10         0x1          
  172.  *
  173.  * [14]    PBIT    WA--    0x5344f0     0xf44f0      0x4b3e4          .data  <<<<<
  174.  *    0    0    0x10         0x1          
  175.  *
  176.  * [15]    PBIT    WA-G    0x57f8d4     0x13f8d4     0x2a84           .got
  177.  *    0    0    0x4          0x4          
  178.  *
  179.  * [16]    PBIT    WA-G    0x582360     0x142360     0x10             .sdata <<<<<
  180.  *    0    0    0x10         0x1          
  181.  *
  182.  * [17]    NOBI    WA-G    0x582370     0x142370     0xb84            .sbss  <<<<<
  183.  *    0    0    0x4          0            
  184.  *
  185.  * [18]    NOBI    WA--    0x582f00     0x142370     0x27ec0          .bss   <<<<<
  186.  *    0    0    0x10         0x1          
  187.  *
  188.  * [19]    SYMT    ----    0            0x142370     0x10e40          .symtab
  189.  *    20    1108    0x4          0x10         
  190.  *
  191.  * [20]    STRT    ----    0            0x1531b0     0xed9e           .strtab
  192.  *    0    0    0x1          0            
  193.  *
  194.  * [21]    STRT    ----    0            0x161f4e     0xb5             .shstrtab
  195.  *    0    0    0x1          0            
  196.  *
  197.  * [22]    PBIT    ----    0            0x162003     0x28e2a          .comment
  198.  *    0    0    0x1          0x1          
  199.  *
  200.  * [23]    PBIT    ----    0            0x18ae2d     0x592            .debug
  201.  *    0    0    0x1          0            
  202.  *
  203.  * [24]    PBIT    ----    0            0x18b3bf     0x80             .line
  204.  *    0    0    0x1          0            
  205.  *
  206.  * [25]    MDBG    ----    0            0x18b440     0x60             .mdebug
  207.  *    0    0    0x4          0            
  208.  *
  209.  *
  210.  * dump -hv emacs
  211.  * 
  212.  * emacs:
  213.  *
  214.  *       **** SECTION HEADER TABLE ****
  215.  * [No]    Type    Flags    Addr         Offset       Size            Name
  216.  *    Link    Info    Adralgn      Entsize
  217.  *
  218.  * [1]    PBIT    -A--    0x4000f4     0xf4         0x13             .interp
  219.  *    0    0    0x1          0            
  220.  *
  221.  * [2]    REGI    -A--    0x400108     0x108        0x18             .reginfo
  222.  *    0    0    0x4          0x18         
  223.  *
  224.  * [3]    DYNM    -A--    0x400120     0x120        0xb8             .dynamic
  225.  *    6    0    0x4          0x8          
  226.  *
  227.  * [4]    HASH    -A--    0x4001d8     0x1d8        0x8a0            .hash
  228.  *    5    0    0x4          0x4          
  229.  *
  230.  * [5]    DYNS    -A--    0x400a78     0xa78        0x11f0           .dynsym
  231.  *    6    2    0x4          0x10         
  232.  *
  233.  * [6]    STRT    -A--    0x401c68     0x1c68       0xbf9            .dynstr
  234.  *    0    0    0x1          0            
  235.  *
  236.  * [7]    REL     -A--    0x402864     0x2864       0x18             .rel.dyn
  237.  *    5    14    0x4          0x8          
  238.  *
  239.  * [8]    PBIT    -AI-    0x402880     0x2880       0x60             .init
  240.  *    0    0    0x10         0x1          
  241.  *
  242.  * [9]    PBIT    -AI-    0x4028e0     0x28e0       0x1234           .plt
  243.  *    0    0    0x4          0x4          
  244.  *
  245.  * [10]    PBIT    -AI-    0x403b20     0x3b20       0xee400          .text
  246.  *    0    0    0x20         0x1          
  247.  *
  248.  * [11]    PBIT    -AI-    0x4f1f20     0xf1f20      0x60             .fini
  249.  *    0    0    0x10         0x1          
  250.  *
  251.  * [12]    PBIT    -A--    0x4f1f80     0xf1f80      0xd90            .rdata
  252.  *    0    0    0x10         0x1          
  253.  *
  254.  * [13]    PBIT    -A--    0x4f2d10     0xf2d10      0x17e0           .rodata
  255.  *    0    0    0x10         0x1          
  256.  *
  257.  * [14]    PBIT    WA--    0x5344f0     0xf44f0      0x4b3e4          .data  <<<<<
  258.  *    0    0    0x10         0x1          
  259.  *
  260.  * [15]    PBIT    WA-G    0x57f8d4     0x13f8d4     0x2a84           .got
  261.  *    0    0    0x4          0x4          
  262.  *
  263.  * [16]    PBIT    WA-G    0x582360     0x142360     0xb94            .sdata <<<<<
  264.  *    0    0    0x10         0x1          
  265.  *
  266.  * [17]    PBIT    WA--    0x582f00     0x142f00     0x94100          .data  <<<<<
  267.  *    0    0    0x10         0x1          
  268.  *
  269.  * [18]    NOBI    WA-G    0x617000     0x1d7000     0                .sbss  <<<<<
  270.  *    0    0    0x4          0            
  271.  *
  272.  * [19]    NOBI    WA--    0x617000     0x1d7000     0                .bss   <<<<<
  273.  *    0    0    0x4          0x1          
  274.  *
  275.  * [20]    SYMT    ----    0            0x1d7000     0x10e40          .symtab
  276.  *    21    1109    0x4          0x10         
  277.  *
  278.  * [21]    STRT    ----    0            0x1e7e40     0xed9e           .strtab
  279.  *    0    0    0x1          0            
  280.  *
  281.  * [22]    STRT    ----    0            0x1f6bde     0xb5             .shstrtab
  282.  *    0    0    0x1          0            
  283.  *
  284.  * [23]    PBIT    ----    0            0x1f6c93     0x28e2a          .comment
  285.  *    0    0    0x1          0x1          
  286.  *
  287.  * [24]    PBIT    ----    0            0x21fabd     0x592            .debug
  288.  *    0    0    0x1          0            
  289.  *
  290.  * [25]    PBIT    ----    0            0x22004f     0x80             .line
  291.  *    0    0    0x1          0            
  292.  *
  293.  * [26]    MDBG    ----    0            0x2200d0     0x60             .mdebug
  294.  *    0    0    0x4          0            
  295.  *
  296.  */
  297.  
  298. #include <sys/types.h>
  299. #include <stdio.h>
  300. #include <sys/stat.h>
  301. #include <memory.h>
  302. #include <string.h>
  303. #include <errno.h>
  304. #include <unistd.h>
  305. #include <fcntl.h>
  306. #include <elf.h>
  307. #include <sys/mman.h>
  308.  
  309. #ifndef emacs
  310. #define fatal(a, b, c) fprintf(stderr, a, b, c), exit(1)
  311. #else
  312. extern void fatal(char *, ...);
  313. #endif
  314.  
  315. /* Get the address of a particular section or program header entry,
  316.  * accounting for the size of the entries.
  317.  */
  318.  
  319. #define OLD_SECTION_H(n) \
  320.      (*(Elf32_Shdr *) ((byte *) old_section_h + old_file_h->e_shentsize * (n)))
  321. #define NEW_SECTION_H(n) \
  322.      (*(Elf32_Shdr *) ((byte *) new_section_h + new_file_h->e_shentsize * (n)))
  323. #define OLD_PROGRAM_H(n) \
  324.      (*(Elf32_Phdr *) ((byte *) old_program_h + old_file_h->e_phentsize * (n)))
  325. #define NEW_PROGRAM_H(n) \
  326.      (*(Elf32_Phdr *) ((byte *) new_program_h + new_file_h->e_phentsize * (n)))
  327.  
  328. #define PATCH_INDEX(n) \
  329.   do { \
  330.      if ((n) >= old_sbss_index) \
  331.        (n) += 1 + (old_sdata_index ? 0 : 1); } while (0)
  332.  
  333. typedef unsigned char byte;
  334.  
  335. /* Round X up to a multiple of Y.  */
  336.  
  337. int
  338. round_up (x, y)
  339.      int x, y;
  340. {
  341.   int rem = x % y;
  342.   if (rem == 0)
  343.     return x;
  344.   return x - rem + y;
  345. }
  346.  
  347. /* ****************************************************************
  348.  * unexec
  349.  *
  350.  * driving logic.
  351.  *
  352.  * In ELF, this works by replacing the old .bss section with a new
  353.  * .data section, and inserting an empty .bss immediately afterwards.
  354.  *
  355.  */
  356. void
  357. unexec (new_name, old_name, data_start, bss_start, entry_address)
  358.      char *new_name, *old_name;
  359.      unsigned data_start, bss_start, entry_address;
  360. {
  361.   extern unsigned int bss_end;
  362.   int new_file, old_file, new_file_size;
  363.  
  364.   /* Pointers to the base of the image of the two files. */
  365.   caddr_t old_base, new_base;
  366.  
  367.   /* Pointers to the file, program and section headers for the old and new
  368.    * files.
  369.    */
  370.   Elf32_Ehdr *old_file_h, *new_file_h;
  371.   Elf32_Phdr *old_program_h, *new_program_h;
  372.   Elf32_Shdr *old_section_h, *new_section_h;
  373.  
  374.   /* Point to the section name table in the old file */
  375.   char *old_section_names;
  376.  
  377.   Elf32_Addr old_bss_addr, new_bss_addr;
  378.   Elf32_Addr old_sbss_addr;
  379.   Elf32_Word old_bss_size, new_data2_size;
  380.   Elf32_Word old_sbss_size, new_data3_size;
  381.   Elf32_Off  new_data2_offset;
  382.   Elf32_Off  new_data3_offset;
  383.   Elf32_Addr new_data2_addr;
  384.   Elf32_Addr new_data3_addr;
  385.  
  386.   Elf32_Word old_sdata_size, new_sdata_size;
  387.   int old_sdata_index = 0;
  388.  
  389.   int n, nn, old_data_index, new_data2_align;
  390.   int old_bss_index;
  391.   int old_sbss_index;
  392.   int old_bss_padding;
  393.   struct stat stat_buf;
  394.  
  395.   /* Open the old file & map it into the address space. */
  396.  
  397.   old_file = open (old_name, O_RDONLY);
  398.  
  399.   if (old_file < 0)
  400.     fatal ("Can't open %s for reading: errno %d\n", old_name, errno);
  401.  
  402.   if (fstat (old_file, &stat_buf) == -1)
  403.     fatal ("Can't fstat(%s): errno %d\n", old_name, errno);
  404.  
  405.   old_base = mmap (0, stat_buf.st_size, PROT_READ, MAP_SHARED, old_file, 0);
  406.  
  407.   if (old_base == (caddr_t) -1)
  408.     fatal ("Can't mmap(%s): errno %d\n", old_name, errno);
  409.  
  410. #ifdef DEBUG
  411.   fprintf (stderr, "mmap(%s, %x) -> %x\n", old_name, stat_buf.st_size,
  412.        old_base);
  413. #endif
  414.  
  415.   /* Get pointers to headers & section names */
  416.  
  417.   old_file_h = (Elf32_Ehdr *) old_base;
  418.   old_program_h = (Elf32_Phdr *) ((byte *) old_base + old_file_h->e_phoff);
  419.   old_section_h = (Elf32_Shdr *) ((byte *) old_base + old_file_h->e_shoff);
  420.   old_section_names = (char *) old_base
  421.     + OLD_SECTION_H(old_file_h->e_shstrndx).sh_offset;
  422.  
  423.   /* Find the old .sbss section.
  424.    */
  425.  
  426.   for (old_sbss_index = 1; old_sbss_index < old_file_h->e_shnum;
  427.        old_sbss_index++)
  428.     {
  429. #ifdef DEBUG
  430.       fprintf (stderr, "Looking for .sbss - found %s\n",
  431.            old_section_names + OLD_SECTION_H(old_sbss_index).sh_name);
  432. #endif
  433.       if (!strcmp (old_section_names + OLD_SECTION_H(old_sbss_index).sh_name,
  434.            ".sbss"))
  435.     break;
  436.     }
  437.   if (old_sbss_index == old_file_h->e_shnum)
  438.     fatal ("Can't find .sbss in %s.\n", old_name, 0);
  439.  
  440.   if (!strcmp(old_section_names + OLD_SECTION_H(old_sbss_index - 1).sh_name,
  441.            ".sdata"))
  442.     {
  443.       old_sdata_index = old_sbss_index - 1;
  444.     }
  445.   
  446.  
  447.   /* Find the old .bss section.
  448.    */
  449.  
  450.   for (old_bss_index = 1; old_bss_index < old_file_h->e_shnum; old_bss_index++)
  451.     {
  452. #ifdef DEBUG
  453.       fprintf (stderr, "Looking for .bss - found %s\n",
  454.            old_section_names + OLD_SECTION_H(old_bss_index).sh_name);
  455. #endif
  456.       if (!strcmp (old_section_names + OLD_SECTION_H(old_bss_index).sh_name,
  457.            ".bss"))
  458.     break;
  459.     }
  460.   if (old_bss_index == old_file_h->e_shnum)
  461.     fatal ("Can't find .bss in %s.\n", old_name, 0);
  462.  
  463.   if (old_sbss_index != (old_bss_index - 1))
  464.     fatal (".sbss should come immediately before .bss in %s.\n", old_name, 0);
  465.  
  466.   /* Figure out parameters of the new data3 and data2 sections.
  467.    * Change the sbss and bss sections.
  468.    */
  469.  
  470.   old_bss_addr = OLD_SECTION_H(old_bss_index).sh_addr;
  471.   old_bss_size = OLD_SECTION_H(old_bss_index).sh_size;
  472.  
  473.   old_sbss_addr = OLD_SECTION_H(old_sbss_index).sh_addr;
  474.   old_sbss_size = OLD_SECTION_H(old_sbss_index).sh_size;
  475.  
  476.   if (old_sdata_index)
  477.     {
  478.     old_sdata_size = OLD_SECTION_H(old_sdata_index).sh_size;
  479.     }
  480.  
  481. #if defined(emacs) || !defined(DEBUG)
  482.   bss_end = (unsigned int) sbrk (0);
  483.   new_bss_addr = (Elf32_Addr) bss_end;
  484. #else
  485.   new_bss_addr = old_bss_addr + old_bss_size + 0x1234;
  486. #endif
  487.   if (old_sdata_index)
  488.     {
  489.     new_sdata_size = OLD_SECTION_H(old_sbss_index).sh_offset -
  490.              OLD_SECTION_H(old_sdata_index).sh_offset + old_sbss_size;
  491.     }
  492.  
  493.   new_data3_addr = old_sbss_addr;
  494.   new_data3_size = old_sbss_size;
  495.   new_data3_offset = OLD_SECTION_H(old_sbss_index).sh_offset;
  496.  
  497.   new_data2_addr = old_bss_addr;
  498.   new_data2_size = new_bss_addr - old_bss_addr;
  499.   new_data2_align = (new_data3_offset + old_sbss_size) %
  500.             OLD_SECTION_H(old_bss_index).sh_addralign;
  501.   new_data2_align = new_data2_align ?
  502.             OLD_SECTION_H(old_bss_index).sh_addralign - new_data2_align :
  503.             0;
  504.   new_data2_offset = new_data3_offset + old_sbss_size + new_data2_align;
  505.  
  506.   old_bss_padding = OLD_SECTION_H(old_bss_index).sh_offset -
  507.             OLD_SECTION_H(old_sbss_index).sh_offset;
  508. #ifdef DEBUG
  509.   fprintf (stderr, "old_bss_index %d\n", old_bss_index);
  510.   fprintf (stderr, "old_bss_addr %x\n", old_bss_addr);
  511.   fprintf (stderr, "old_bss_size %x\n", old_bss_size);
  512.   fprintf (stderr, "new_bss_addr %x\n", new_bss_addr);
  513.   fprintf (stderr, "new_data2_addr %x\n", new_data2_addr);
  514.   fprintf (stderr, "new_data2_size %x\n", new_data2_size);
  515.   fprintf (stderr, "new_data2_offset %x\n", new_data2_offset);
  516.   fprintf (stderr, "old_sbss_index %d\n", old_sbss_index);
  517.   fprintf (stderr, "old_sbss_addr %x\n", old_sbss_addr);
  518.   fprintf (stderr, "old_sbss_size %x\n", old_sbss_size);
  519.   if (old_sdata_index)
  520.     {
  521.     fprintf (stderr, "old_sdata_size %x\n", old_sdata_size);
  522.     fprintf (stderr, "new_sdata_size %x\n", new_sdata_size);
  523.     }
  524.   else
  525.     {
  526.     fprintf (stderr, "new_data3_addr %x\n", new_data3_addr);
  527.     fprintf (stderr, "new_data3_size %x\n", new_data3_size);
  528.     fprintf (stderr, "new_data3_offset %x\n", new_data3_offset);
  529.     }
  530. #endif
  531.  
  532.   if ((unsigned) new_bss_addr < (unsigned) old_bss_addr + old_bss_size)
  533.     fatal (".bss shrank when undumping???\n", 0, 0);
  534.  
  535.   /* Set the output file to the right size and mmap(2) it.  Set
  536.    * pointers to various interesting objects.  stat_buf still has
  537.    * old_file data.
  538.    */
  539.  
  540.   new_file = open (new_name, O_RDWR | O_CREAT, 0666);
  541.   if (new_file < 0)
  542.     fatal ("Can't creat(%s): errno %d\n", new_name, errno);
  543.  
  544.   new_file_size = stat_buf.st_size +
  545.           ((1 + (old_sdata_index ? 0 : 1)) * old_file_h->e_shentsize) +
  546.           new_data2_size + new_data3_size + new_data2_align;
  547.  
  548.   if (ftruncate (new_file, new_file_size))
  549.     fatal ("Can't ftruncate(%s): errno %d\n", new_name, errno);
  550.  
  551.   new_base = mmap (0, new_file_size, PROT_READ | PROT_WRITE, MAP_SHARED,
  552.            new_file, 0);
  553.  
  554.   if (new_base == (caddr_t) -1)
  555.     fatal ("Can't mmap(%s): errno %d\n", new_name, errno);
  556.  
  557.   new_file_h = (Elf32_Ehdr *) new_base;
  558.   new_program_h = (Elf32_Phdr *) ((byte *) new_base + old_file_h->e_phoff);
  559.   new_section_h = (Elf32_Shdr *) ((byte *) new_base +
  560.                   old_file_h->e_shoff +
  561.                   new_data2_size +
  562.                   new_data2_align +
  563.                   new_data3_size);
  564.  
  565.   /* Make our new file, program and section headers as copies of the
  566.    * originals.
  567.    */
  568.  
  569.   memcpy (new_file_h, old_file_h, old_file_h->e_ehsize);
  570.   memcpy (new_program_h, old_program_h,
  571.       old_file_h->e_phnum * old_file_h->e_phentsize);
  572.  
  573.   /* Modify the e_shstrndx if necessary. */
  574.   PATCH_INDEX (new_file_h->e_shstrndx);
  575.  
  576.   /* Fix up file header.  We'll add one section.  Section header is
  577.    * further away now.
  578.    */
  579.  
  580.   new_file_h->e_shoff += new_data2_size + new_data2_align + new_data3_size;
  581.   new_file_h->e_shnum += 1 + (old_sdata_index ? 0 : 1);
  582.  
  583. #ifdef DEBUG
  584.   fprintf (stderr, "Old section offset %x\n", old_file_h->e_shoff);
  585.   fprintf (stderr, "Old section count %d\n", old_file_h->e_shnum);
  586.   fprintf (stderr, "New section offset %x\n", new_file_h->e_shoff);
  587.   fprintf (stderr, "New section count %d\n", new_file_h->e_shnum);
  588. #endif
  589.  
  590.   /* Fix up a new program header.  Extend the writable data segment so
  591.    * that the bss area is covered too. Find that segment by looking
  592.    * for a segment that ends just before the .bss area.  Make sure
  593.    * that no segments are above the new .data2.  Put a loop at the end
  594.    * to adjust the offset and address of any segment that is above
  595.    * data2, just in case we decide to allow this later.
  596.    */
  597.  
  598.   for (n = new_file_h->e_phnum - 1; n >= 0; n--)
  599.     {
  600.       /* Compute maximum of all requirements for alignment of section.  */
  601.       int alignment = (NEW_PROGRAM_H (n)).p_align;
  602.       if ((OLD_SECTION_H (old_bss_index)).sh_addralign > alignment)
  603.     alignment = OLD_SECTION_H (old_bss_index).sh_addralign;
  604.  
  605.       if ((OLD_SECTION_H (old_sbss_index)).sh_addralign > alignment)
  606.     alignment = OLD_SECTION_H (old_sbss_index).sh_addralign;
  607.  
  608.       /* Supposedly this condition is okay for the SGI.  */
  609. #if 0
  610.       if (NEW_PROGRAM_H(n).p_vaddr + NEW_PROGRAM_H(n).p_filesz > old_bss_addr)
  611.     fatal ("Program segment above .bss in %s\n", old_name, 0);
  612. #endif
  613.  
  614.       if (NEW_PROGRAM_H(n).p_type == PT_LOAD
  615.       && (round_up ((NEW_PROGRAM_H (n)).p_vaddr
  616.             + (NEW_PROGRAM_H (n)).p_filesz,
  617.             alignment)
  618.           == round_up (old_bss_addr, alignment)))
  619.     break;
  620.     }
  621.   if (n < 0)
  622.     fatal ("Couldn't find segment next to .bss in %s\n", old_name, 0);
  623.  
  624.   NEW_PROGRAM_H(n).p_filesz += new_data2_size + new_data2_align +
  625.     new_data3_size;
  626.   NEW_PROGRAM_H(n).p_memsz = NEW_PROGRAM_H(n).p_filesz;
  627.  
  628. #if 1 /* Maybe allow section after data2 - does this ever happen? */
  629.   for (n = new_file_h->e_phnum - 1; n >= 0; n--)
  630.     {
  631.       if (NEW_PROGRAM_H(n).p_vaddr
  632.       && NEW_PROGRAM_H(n).p_vaddr >= new_data3_addr)
  633.     NEW_PROGRAM_H(n).p_vaddr += new_data2_size - old_bss_size +
  634.                     new_data3_size - old_sbss_size;
  635.  
  636.       if (NEW_PROGRAM_H(n).p_offset >= new_data3_offset)
  637.     NEW_PROGRAM_H(n).p_offset += new_data2_size + new_data2_align +
  638.       new_data3_size;
  639.     }
  640. #endif
  641.  
  642.   /* Fix up section headers based on new .data2 section.  Any section
  643.    * whose offset or virtual address is after the new .data2 section
  644.    * gets its value adjusted.  .bss size becomes zero and new address
  645.    * is set.  data2 section header gets added by copying the existing
  646.    * .data header and modifying the offset, address and size.
  647.    */
  648.   for (old_data_index = 1; old_data_index < old_file_h->e_shnum;
  649.        old_data_index++)
  650.     if (!strcmp (old_section_names + OLD_SECTION_H(old_data_index).sh_name,
  651.          ".data"))
  652.       break;
  653.   if (old_data_index == old_file_h->e_shnum)
  654.     fatal ("Can't find .data in %s.\n", old_name, 0);
  655.  
  656.   /* Walk through all section headers, insert the new data2 section right 
  657.      before the new bss section. */
  658.   for (n = 1, nn = 1; n < old_file_h->e_shnum; n++, nn++)
  659.     {
  660.       caddr_t src;
  661.  
  662.       if (n == old_sbss_index)
  663.  
  664.       /* If it is sbss section, insert the new data3 section before it. */
  665.     {
  666.       /* Steal the data section header for this data3 section. */
  667.       if (!old_sdata_index)
  668.         {
  669.         memcpy (&NEW_SECTION_H(nn), &OLD_SECTION_H(old_data_index),
  670.             new_file_h->e_shentsize);
  671.       
  672.         NEW_SECTION_H(nn).sh_addr = new_data3_addr;
  673.         NEW_SECTION_H(nn).sh_offset = new_data3_offset;
  674.         NEW_SECTION_H(nn).sh_size = new_data3_size;
  675.         NEW_SECTION_H(nn).sh_flags = OLD_SECTION_H(n).sh_flags;
  676.         /* Use the sbss section's alignment. This will assure that the
  677.            new data3 section always be placed in the same spot as the old
  678.            sbss section by any other application. */
  679.         NEW_SECTION_H(nn).sh_addralign = OLD_SECTION_H(n).sh_addralign;
  680.  
  681.         /* Now copy over what we have in the memory now. */
  682.         memcpy (NEW_SECTION_H(nn).sh_offset + new_base, 
  683.             (caddr_t) OLD_SECTION_H(n).sh_addr, 
  684.             new_data3_size);
  685.           /* the new .data2 section should also come before the
  686.            * new .sbss section */
  687.         nn += 2;
  688.         }
  689.       else
  690.         {
  691.         /* We always have a .sdata section: append the contents of the
  692.          * old .sbss section.
  693.          */
  694.         memcpy (new_data3_offset + new_base, 
  695.             (caddr_t) OLD_SECTION_H(n).sh_addr, 
  696.             new_data3_size);
  697.         nn ++;
  698.         }
  699.     }
  700.       else if (n == old_bss_index)
  701.       
  702.       /* If it is bss section, insert the new data2 section before it. */
  703.     {
  704.       Elf32_Word tmp_align;
  705.       Elf32_Addr tmp_addr;
  706.  
  707.       tmp_align = OLD_SECTION_H(n).sh_addralign;
  708.       tmp_addr = OLD_SECTION_H(n).sh_addr;
  709.  
  710.       nn -= 2;
  711.       /* Steal the data section header for this data2 section. */
  712.       memcpy (&NEW_SECTION_H(nn), &OLD_SECTION_H(old_data_index),
  713.           new_file_h->e_shentsize);
  714.       
  715.       NEW_SECTION_H(nn).sh_addr = new_data2_addr;
  716.       NEW_SECTION_H(nn).sh_offset = new_data2_offset;
  717.       NEW_SECTION_H(nn).sh_size = new_data2_size;
  718.       /* Use the bss section's alignment. This will assure that the
  719.          new data2 section always be placed in the same spot as the old
  720.          bss section by any other application. */
  721.       NEW_SECTION_H(nn).sh_addralign = tmp_align;
  722.  
  723.       /* Now copy over what we have in the memory now. */
  724.       memcpy (NEW_SECTION_H(nn).sh_offset + new_base, 
  725.           (caddr_t) tmp_addr, new_data2_size);
  726.       nn += 2;
  727.     }
  728.       
  729.       memcpy (&NEW_SECTION_H(nn), &OLD_SECTION_H(n), 
  730.           old_file_h->e_shentsize);
  731.       
  732.       if (old_sdata_index && n == old_sdata_index)
  733.     /* The old .sdata section has now a new size */
  734.     NEW_SECTION_H(nn).sh_size = new_sdata_size;
  735.  
  736.       /* The new bss section's size is zero, and its file offset and virtual
  737.      address should be off by NEW_DATA2_SIZE. */
  738.       if (n == old_sbss_index)
  739.     {
  740.       /* NN should be `old_sbss_index + 2' at this point. */
  741.       NEW_SECTION_H(nn).sh_offset += new_data2_size + new_data2_align +
  742.         new_data3_size;
  743.       NEW_SECTION_H(nn).sh_addr += new_data2_size + new_data2_align +
  744.         new_data3_size;
  745.       /* Let the new bss section address alignment be the same as the
  746.          section address alignment followed the old bss section, so 
  747.          this section will be placed in exactly the same place. */
  748.       NEW_SECTION_H(nn).sh_addralign =
  749.         OLD_SECTION_H(nn + (old_sdata_index ? 1 : 0)).sh_addralign;
  750.       NEW_SECTION_H(nn).sh_size = 0;
  751.     }
  752.       else if (n == old_bss_index)
  753.     {
  754.       /* NN should be `old_bss_index + 2' at this point. */
  755.       NEW_SECTION_H(nn).sh_offset += new_data2_size + new_data2_align +
  756.         new_data3_size - old_bss_padding;
  757.       NEW_SECTION_H(nn).sh_addr += new_data2_size;
  758.       /* Let the new bss section address alignment be the same as the
  759.          section address alignment followed the old bss section, so 
  760.          this section will be placed in exactly the same place. */
  761.       NEW_SECTION_H(nn).sh_addralign =
  762.         OLD_SECTION_H((nn - (old_sdata_index ? 0 : 1))).sh_addralign;
  763.       NEW_SECTION_H(nn).sh_size = 0;
  764.     }
  765.       /* Any section that was original placed AFTER the bss section should now
  766.      be off by NEW_DATA2_SIZE. */
  767.       else if (NEW_SECTION_H(nn).sh_offset >= new_data3_offset)
  768.     NEW_SECTION_H(nn).sh_offset += new_data2_size +
  769.                        new_data2_align +
  770.                        new_data3_size -
  771.                        old_bss_padding;
  772.       
  773.       /* If any section hdr refers to the section after the new .data
  774.      section, make it refer to next one because we have inserted 
  775.      a new section in between. */
  776.       
  777.       PATCH_INDEX(NEW_SECTION_H(nn).sh_link);
  778.       PATCH_INDEX(NEW_SECTION_H(nn).sh_info);
  779.       
  780.       /* Now, start to copy the content of sections. */
  781.       if (NEW_SECTION_H(nn).sh_type == SHT_NULL
  782.       || NEW_SECTION_H(nn).sh_type == SHT_NOBITS)
  783.     continue;
  784.       
  785.       /* Write out the sections. .data, .data1 and .sdata get copied from
  786.        * the current process instead of the old file.
  787.        */
  788.       if (!strcmp (old_section_names + OLD_SECTION_H(n).sh_name, ".data") ||
  789.       !strcmp (old_section_names + OLD_SECTION_H(n).sh_name, ".data1") ||
  790.       (old_sdata_index && (n == old_sdata_index)))
  791.     src = (caddr_t) OLD_SECTION_H(n).sh_addr;
  792.       else
  793.     src = old_base + OLD_SECTION_H(n).sh_offset;
  794.       
  795.       memcpy (NEW_SECTION_H(nn).sh_offset + new_base, src,
  796.           ((n == old_sdata_index) ?
  797.            old_sdata_size :
  798.            NEW_SECTION_H(nn).sh_size));
  799.  
  800.       /* If it is the symbol table, its st_shndx field needs to be patched. */
  801.       if (NEW_SECTION_H(nn).sh_type == SHT_SYMTAB
  802.       || NEW_SECTION_H(nn).sh_type == SHT_DYNSYM)
  803.     {
  804.       Elf32_Shdr *spt = &NEW_SECTION_H(nn);
  805.       unsigned int num = spt->sh_size / spt->sh_entsize;
  806.       Elf32_Sym * sym = (Elf32_Sym *) (NEW_SECTION_H(nn).sh_offset + 
  807.                        new_base);
  808.       for (; num--; sym++)
  809.         {
  810.           if ((sym->st_shndx == SHN_UNDEF)
  811.           || (sym->st_shndx == SHN_ABS)
  812.           || (sym->st_shndx == SHN_COMMON))
  813.         continue;
  814.     
  815.           PATCH_INDEX(sym->st_shndx);
  816.         }
  817.     }
  818.     }
  819.  
  820.   /* Close the files and make the new file executable */
  821.  
  822.   if (close (old_file))
  823.     fatal ("Can't close(%s): errno %d\n", old_name, errno);
  824.  
  825.   if (close (new_file))
  826.     fatal ("Can't close(%s): errno %d\n", new_name, errno);
  827.  
  828.   if (stat (new_name, &stat_buf) == -1)
  829.     fatal ("Can't stat(%s): errno %d\n", new_name, errno);
  830.  
  831.   n = umask (777);
  832.   umask (n);
  833.   stat_buf.st_mode |= 0111 & ~n;
  834.   if (chmod (new_name, stat_buf.st_mode) == -1)
  835.     fatal ("Can't chmod(%s): errno %d\n", new_name, errno);
  836. }
  837.