outfile.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 1988 AT&T
* All Rights Reserved
*
*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* This file contains the functions responsible for opening the output file
* image, associating the appropriate input elf structures with the new image,
* and obtaining new elf structures to define the new image.
*/
#include <stdio.h>
#include <fcntl.h>
#include <link.h>
#include <errno.h>
#include <string.h>
#include <limits.h>
#include "msg.h"
#include "_libld.h"
#include <debug.h>
/*
* Open the output file and insure the correct access modes.
*/
{
int exists = 0;
/*
* Determine the required file mode from the type of output file we
* are creating.
*/
mode = 0777;
else
mode = 0666;
/*
* Determine if the output file already exists.
*/
exists++;
/*
* Open (or create) the output file name (ofl_fd acts as a global
* flag to ldexit() signifying whether the output file should be
* removed or not on error).
*/
mode)) < 0) {
return (S_ERROR);
}
/*
* If we've just created this file the modes will be fine, however if
* the file had already existed make sure the modes are correct.
*/
if (exists) {
/*
* If the output file is not a regular file, don't change the
* mode, or allow it to be deleted. This allows root users to
*/
} else {
}
}
return (1);
}
/*
* If we are creating a memory model we need to update the present memory image.
* First we need to call elf_update(ELF_C_NULL) which will calculate the offsets
* of each section and its associated data buffers. From this information we
* can then determine what padding is required.
* Two actions are necessary to convert the present disc image into a memory
* image:
*
* o Loadable segments must be padded so that the next segments virtual
* address and file offset are the same.
*
* o NOBITS sections must be converted into allocated, null filled sections.
*/
{
/*
* Update all the elf structures. This will assign offsets to the
* section headers and data buffers as they relate to the new image.
*/
return (S_ERROR);
}
return (S_ERROR);
}
/*
* Initialize the offset by skipping the Elf header and program
* headers.
*/
/*
* Traverse the segment list looking for loadable segments.
*/
/*
* If we've already processed a loadable segment, the `scn'
* variable will be initialized to the last section that was
* part of that segment. Add sufficient padding to this section
* to cause the next segments virtual address and file offset to
* be the same.
*/
offset);
return (S_ERROR);
}
return (S_ERROR);
}
/*
* Traverse the output sections for this segment calculating the
* offset of each section. Retain the final section descriptor
* as this will be where any padding buffer will be added.
*/
/*
* If this is a NOBITS output section convert all of
* its associated input sections into real, null filled,
* data buffers, and change the section to PROGBITS.
*/
}
/*
* If this is a loadable segment retain the last output section
* descriptor. This acts both as a flag that a loadable
* segment has been seen, and as the segment to which a padding
* buffer will be added.
*/
}
return (1);
}
/*
* Create the elf structures that allow the input data to be associated with the
* new image:
*
* o define the new elf image using elf_begin(),
*
* o obtain an elf header for the image,
*
* o traverse the input segments and create a program header array
* to define the required segments,
*
* o traverse the output sections for each segment assigning a new
* section descriptor and section header for each,
*
* o traverse the input sections associated with each output section
* and assign a new data descriptor to each (each output section
* becomes a linked list of input data buffers).
*/
{
tlsidx = 0;
/*
* If FLG_OF1_NOHDR was set in map_parse() or FLG_OF1_VADDR was set,
* we need to do alignment adjustment.
*/
}
if (flags & FLG_OF_MEMORY) {
cmd = ELF_C_IMAGE;
fd = 0;
} else {
cmd = ELF_C_WRITE;
}
/*
* If there are any ordered section, handle them here.
*/
return (S_ERROR);
/*
* Tell the access library about our new temporary file.
*/
return (S_ERROR);
}
/*
* Obtain a new Elf header.
*/
return (S_ERROR);
}
DBG_CALL(Dbg_util_nl());
/*
* Count the number of segments that will go in the program
* header table. If a segment is empty, ignore it.
*/
int frst = 0;
if (!(flags & FLG_OF_RELOBJ)) {
/*
* If we are generating an interp section (and
* thus an associated PT_INTERP program header
* entry) also generate a PT_PHDR program header
* entry. This allows the kernel to generate
* the appropriate aux vector entries to pass to
* Note that if an image was generated with an
* interp section, but no associated PT_PHDR
* program header entry, the kernel will simply
* pass the interpreter an open file descriptor
* when the image is executed).
*/
if (ofl->ofl_osinterp)
nseg++;
if (ofl->ofl_osinterp)
nseg++;
} else if (ptype == PT_DYNAMIC) {
if (flags & FLG_OF_DYNAMIC)
nseg++;
nseg++;
} else if (ptype == PT_SUNW_UNWIND) {
if (ofl->ofl_unwindhdr)
nseg++;
#endif
} else if (ptype == PT_SUNWBSS) {
if (ofl->ofl_issunwbss)
nseg++;
} else if (ptype == PT_SUNWSTACK) {
nseg++;
} else if (ptype == PT_SUNWDTRACE) {
if (ofl->ofl_dtracesym)
nseg++;
} else if (ptype == PT_SUNWCAP) {
nseg++;
nseg++;
}
}
/*
* If the first loadable segment has the ?N flag,
* then ?N will be on.
*/
ptloadidx++;
}
}
shidx = 0;
shidx++;
/*
* Get a section descriptor for the section.
*/
return (S_ERROR);
}
/*
* Get a new section header table entry and copy the
* pertinent information from the in-core descriptor.
* As we had originally allocated the section header
* (refer place_section()) we might as well free it up.
*/
return (S_ERROR);
}
(shidx == 1))
/*
* Knock off the SHF_ORDERED & SHF_LINK_ORDER flags.
*/
/*
* If we are not building a RELOBJ - we strip
* off the SHF_GROUP flag (if present).
*/
dataidx = 0;
/*
* At this point we know whether a section has
* been referenced. If it hasn't, and the whole
* file hasn't been referenced (which would have
* been caught in ignore_section_processing()),
* give a diagnostic (-D unused,detail) or
* discard the section if -zignore is in effect.
*/
if (ifl &&
continue;
} else
}
dataidx++;
/*
* If this section provides no data, and isn't
* referenced, then it can be discarded as well.
* Note, if this is the first input section
* associated to an output section, let it
* through, there may be a legitimate reason why
* the user wants a null section. Discarding
* additional sections is intended to remove the
* empty clutter the compilers have a habit of
* creating. Don't provide an unused diagnostic
* as these sections aren't typically the users
* creation.
*/
continue;
}
/*
* Create new output data buffers for each of
* the input data buffers, thus linking the new
* buffers to the new elf output structures.
* Simply make the new data buffers point to
* the old data.
*/
return (S_ERROR);
}
}
/*
* Make sure that the first tls section is
* aligned on pointer size alignment.
*/
if ((tlsidx == 0) &&
tlsidx = 1;
}
/*
* 4106312, the 32-bit ELF64 version of ld
* needs to be able to create large .bss
* sections. The d_size member of Elf_Data
* only allows 32-bits in _ILP32, so we build
* multiple data-items that each fit into 32-
* bits. libelf (4106398) can summ these up
* into a 64-bit quantity. This only works
* for NOBITS sections which don't have any
* real data to maintain and don't require
* large file support.
*/
while (sz >> 32) {
if ((data =
return (S_ERROR);
}
}
#endif
/*
* If this segment requires rounding realign the
* first data buffer associated with the first
* section.
*/
if ((frst++ == 0) &&
else
}
}
/*
* Clear the szoutrels counter so that it can be used
* again in the building of relocs. See machrel.c.
*/
osp->os_szoutrels = 0;
}
}
/*
* Build an empty PHDR.
*/
if (nseg) {
return (S_ERROR);
}
}
/*
* If we need to generate a memory model, pad the image.
*/
if (flags & FLG_OF_MEMORY) {
return (S_ERROR);
}
/*
* After all the basic input file processing, all data pointers are
* referencing two types of memory:
*
* o allocated memory, ie. elf structures, internal link
* editor structures, and any new sections that have been
* created.
*
* o original input file mmap'ed memory, ie. the actual data
* sections of the input file images.
*
* Up until now, the only memory modifications have been carried out on
* the allocated memory. Before carrying out any relocations, write the
* new output file image and reassign any necessary data pointers to the
* output files memory image. This insures that any relocation
* modifications are made to the output file image and not to the input
* file image, thus preventing the creation of dirty pages and reducing
* the overall swap space requirement.
*
* Write out the elf structure so as to create the new file image.
*/
return (S_ERROR);
}
/*
* Initialize the true `ofl' information with the memory images address
* and size. This will be used to write() out the image once any
* relocation processing has been completed. We also use this image
* information to setup a new Elf descriptor, which is used to obtain
* all the necessary elf pointers within the new output image.
*/
return (S_ERROR);
}
return (S_ERROR);
}
if (!(flags & FLG_OF_RELOBJ))
return (S_ERROR);
}
/*
* Reinitialize the section descriptors, section headers and obtain new
* output data buffer pointers (these will be used to perform any
* relocations).
*/
NULL) {
return (S_ERROR);
}
NULL) {
return (S_ERROR);
}
return (S_ERROR);
}
}
}
if ((osp->os_outdata =
return (S_ERROR);
}
/*
* If this section is part of a loadable segment insure
* that the segments alignment is appropriate.
*/
}
}
}
return (1);
}