xref: /titanic_51/usr/src/cmd/sgs/libld/common/outfile.c (revision a972924280e9420519267ece8fcddfb8fc29a96b)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  *	Copyright (c) 1988 AT&T
24  *	  All Rights Reserved
25  *
26  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
27  * Use is subject to license terms.
28  */
29 
30 /*
31  * This file contains the functions responsible for opening the output file
32  * image, associating the appropriate input elf structures with the new image,
33  * and obtaining new elf structures to define the new image.
34  */
35 #include	<stdio.h>
36 #include	<sys/stat.h>
37 #include	<fcntl.h>
38 #include	<link.h>
39 #include	<errno.h>
40 #include	<string.h>
41 #include	<limits.h>
42 #include	<debug.h>
43 #include	<unistd.h>
44 #include	"msg.h"
45 #include	"_libld.h"
46 
47 /*
48  * Determine a least common multiplier.  Input sections contain an alignment
49  * requirement, which elf_update() uses to insure that the section is aligned
50  * correctly off of the base of the elf image.  We must also insure that the
51  * sections mapping is congruent with this alignment requirement.  For each
52  * input section associated with a loadable segment determine whether the
53  * segments alignment must be adjusted to compensate for a sections alignment
54  * requirements.
55  */
56 Xword
57 ld_lcm(Xword a, Xword b)
58 {
59 	Xword	_r, _a, _b;
60 
61 	if ((_a = a) == 0)
62 		return (b);
63 	if ((_b = b) == 0)
64 		return (a);
65 
66 	if (_a > _b)
67 		_a = b, _b = a;
68 	while ((_r = _b % _a) != 0)
69 		_b = _a, _a = _r;
70 	return ((a / _a) * b);
71 }
72 
73 /*
74  * Open the output file and insure the correct access modes.
75  */
76 uintptr_t
77 ld_open_outfile(Ofl_desc * ofl)
78 {
79 	mode_t		mode;
80 	struct stat	status;
81 
82 	/*
83 	 * Determine the required file mode from the type of output file we
84 	 * are creating.
85 	 */
86 	mode = (ofl->ofl_flags & (FLG_OF_EXEC | FLG_OF_SHAROBJ))
87 	    ? 0777 : 0666;
88 
89 	/* Determine if the output file already exists */
90 	if (stat(ofl->ofl_name, &status) == 0) {
91 		if ((status.st_mode & S_IFMT) != S_IFREG) {
92 			/*
93 			 * It is not a regular file, so don't delete it
94 			 * or allow it to be deleted.  This allows root
95 			 * users to specify /dev/null output file for
96 			 * verification links.
97 			 */
98 			ofl->ofl_flags1 |= FLG_OF1_NONREG;
99 		} else {
100 			/*
101 			 * It's a regular file, so unlink it. In standard
102 			 * Unix fashion, the old file will continue to
103 			 * exist until its link count drops to 0 and no
104 			 * process has the file open. In the meantime, we
105 			 * create a new file (inode) under the same name,
106 			 * available for new use.
107 			 *
108 			 * The advantage of this policy is that creating
109 			 * a new executable or sharable library does not
110 			 * corrupt existing processes using the old file.
111 			 * A possible disadvantage is that if the existing
112 			 * file has a (link_count > 1), the other names will
113 			 * continue to reference the old inode, thus
114 			 * breaking the link.
115 			 *
116 			 * A subtlety here is that POSIX says we are not
117 			 * supposed to replace a non-writable file, which
118 			 * is something that unlink() is happy to do. The
119 			 * only 100% reliable test against this is to open
120 			 * the file for non-destructive write access. If the
121 			 * open succeeds, we are clear to unlink it, and if
122 			 * not, then the error generated is the error we
123 			 * need to report.
124 			 */
125 			if ((ofl->ofl_fd = open(ofl->ofl_name, O_RDWR,
126 			    mode)) < 0) {
127 				int	err = errno;
128 
129 				if (err != ENOENT) {
130 					eprintf(ofl->ofl_lml, ERR_FATAL,
131 					    MSG_INTL(MSG_SYS_OPEN),
132 					    ofl->ofl_name, strerror(err));
133 					return (S_ERROR);
134 				}
135 			} else {
136 				(void) close(ofl->ofl_fd);
137 			}
138 
139 			if ((unlink(ofl->ofl_name) == -1) &&
140 			    (errno != ENOENT)) {
141 				int err = errno;
142 
143 				eprintf(ofl->ofl_lml, ERR_FATAL,
144 				    MSG_INTL(MSG_SYS_UNLINK),
145 				    ofl->ofl_name, strerror(err));
146 				return (S_ERROR);
147 			}
148 		}
149 	}
150 
151 	/*
152 	 * Open (or create) the output file name (ofl_fd acts as a global
153 	 * flag to ldexit() signifying whether the output file should be
154 	 * removed or not on error).
155 	 */
156 	if ((ofl->ofl_fd = open(ofl->ofl_name, O_RDWR | O_CREAT | O_TRUNC,
157 	    mode)) < 0) {
158 		int	err = errno;
159 
160 		eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_SYS_OPEN),
161 		    ofl->ofl_name, strerror(err));
162 		return (S_ERROR);
163 	}
164 
165 	return (1);
166 }
167 
168 
169 /*
170  * If we are creating a memory model we need to update the present memory image.
171  * First we need to call elf_update(ELF_C_NULL) which will calculate the offsets
172  * of each section and its associated data buffers.  From this information we
173  * can then determine what padding is required.
174  * Two actions are necessary to convert the present disc image into a memory
175  * image:
176  *
177  *  o	Loadable segments must be padded so that the next segments virtual
178  *	address and file offset are the same.
179  *
180  *  o	NOBITS sections must be converted into allocated, null filled sections.
181  */
182 static uintptr_t
183 pad_outfile(Ofl_desc *ofl)
184 {
185 	Listnode	*lnp;
186 	off_t		offset;
187 	Elf_Scn		*oscn = 0;
188 	Sg_desc		*sgp;
189 	Ehdr		*ehdr;
190 
191 	/*
192 	 * Update all the elf structures.  This will assign offsets to the
193 	 * section headers and data buffers as they relate to the new image.
194 	 */
195 	if (elf_update(ofl->ofl_welf, ELF_C_NULL) == -1) {
196 		eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_UPDATE),
197 		    ofl->ofl_name);
198 		return (S_ERROR);
199 	}
200 	if ((ehdr = elf_getehdr(ofl->ofl_welf)) == NULL) {
201 		eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETEHDR),
202 		    ofl->ofl_name);
203 		return (S_ERROR);
204 	}
205 
206 	/*
207 	 * Initialize the offset by skipping the Elf header and program
208 	 * headers.
209 	 */
210 	offset = ehdr->e_phoff + (ehdr->e_phnum * ehdr->e_phentsize);
211 
212 	/*
213 	 * Traverse the segment list looking for loadable segments.
214 	 */
215 	for (LIST_TRAVERSE(&ofl->ofl_segs, lnp, sgp)) {
216 		Phdr	*phdr = &(sgp->sg_phdr);
217 		Os_desc	*osp;
218 		Aliste	idx;
219 
220 		/*
221 		 * If we've already processed a loadable segment, the `scn'
222 		 * variable will be initialized to the last section that was
223 		 * part of that segment.  Add sufficient padding to this section
224 		 * to cause the next segments virtual address and file offset to
225 		 * be the same.
226 		 */
227 		if (oscn && (phdr->p_type == PT_LOAD)) {
228 			Elf_Data *	data;
229 			size_t 		size;
230 
231 			size = (size_t)(S_ROUND(offset, phdr->p_align) -
232 			    offset);
233 
234 			if ((data = elf_newdata(oscn)) == NULL) {
235 				eprintf(ofl->ofl_lml, ERR_ELF,
236 				    MSG_INTL(MSG_ELF_NEWDATA), ofl->ofl_name);
237 				return (S_ERROR);
238 			}
239 			if ((data->d_buf = libld_calloc(size, 1)) == 0)
240 				return (S_ERROR);
241 
242 			data->d_type = ELF_T_BYTE;
243 			data->d_size = size;
244 			data->d_align = 1;
245 			data->d_version = ofl->ofl_dehdr->e_version;
246 		}
247 
248 		/*
249 		 * Traverse the output sections for this segment calculating the
250 		 * offset of each section. Retain the final section descriptor
251 		 * as this will be where any padding buffer will be added.
252 		 */
253 		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx, osp)) {
254 			Shdr	*shdr = osp->os_shdr;
255 
256 			offset = (off_t)S_ROUND(offset, shdr->sh_addralign);
257 			offset += shdr->sh_size;
258 
259 			/*
260 			 * If this is a NOBITS output section convert all of
261 			 * its associated input sections into real, null filled,
262 			 * data buffers, and change the section to PROGBITS.
263 			 */
264 			if (shdr->sh_type == SHT_NOBITS)
265 				shdr->sh_type = SHT_PROGBITS;
266 		}
267 
268 		/*
269 		 * If this is a loadable segment retain the last output section
270 		 * descriptor.  This acts both as a flag that a loadable
271 		 * segment has been seen, and as the segment to which a padding
272 		 * buffer will be added.
273 		 */
274 		if (phdr->p_type == PT_LOAD)
275 			oscn = osp->os_scn;
276 	}
277 	return (1);
278 }
279 
280 /*
281  * Create an output section.  The first instance of an input section triggers
282  * the creation of a new output section.
283  */
284 static uintptr_t
285 create_outsec(Ofl_desc *ofl, Sg_desc *sgp, Os_desc *osp, Word ptype, int shidx,
286     Boolean fixalign)
287 {
288 	Elf_Scn	*scn;
289 	Shdr	*shdr;
290 
291 	/*
292 	 * Get a section descriptor for the section.
293 	 */
294 	if ((scn = elf_newscn(ofl->ofl_welf)) == NULL) {
295 		eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_NEWSCN),
296 		    ofl->ofl_name);
297 		return (S_ERROR);
298 	}
299 	osp->os_scn = scn;
300 
301 	/*
302 	 * Get a new section header table entry and copy the pertinent
303 	 * information from the in-core descriptor.
304 	 */
305 	if ((shdr = elf_getshdr(scn)) == NULL) {
306 		eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR),
307 		    ofl->ofl_name);
308 		return (S_ERROR);
309 	}
310 	*shdr = *(osp->os_shdr);
311 	osp->os_shdr = shdr;
312 
313 	/*
314 	 * If this is the first section within a loadable segment, and the
315 	 * alignment needs to be updated, record this section.
316 	 */
317 	if ((fixalign == TRUE) && (ptype == PT_LOAD) && (shidx == 1))
318 		sgp->sg_fscn = scn;
319 
320 	/*
321 	 * If not building a relocatable object, remove any of the
322 	 * following flags, as they have been acted upon and are not
323 	 * meaningful in the output:
324 	 *	SHF_ORDERED, SHF_LINK_ORDER, SHF_GROUP
325 	 * For relocatable objects, we allow them to propagate to
326 	 * the output object to be handled by the next linker that
327 	 * sees them.
328 	 */
329 	if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)
330 		osp->os_shdr->sh_flags &= ~(ALL_SHF_ORDER|SHF_GROUP);
331 
332 	/*
333 	 * If this is a TLS section, save it so that the PT_TLS program header
334 	 * information can be established after the output image has been
335 	 * initially created.  At this point, all TLS input sections are ordered
336 	 * as they will appear in the output image.
337 	 */
338 	if ((ofl->ofl_flags & FLG_OF_TLSPHDR) &&
339 	    (osp->os_shdr->sh_flags & SHF_TLS) &&
340 	    (list_appendc(&ofl->ofl_ostlsseg, osp) == 0))
341 		return (S_ERROR);
342 
343 	return (0);
344 }
345 
346 /*
347  * Recalculate the number of output sections and update ofl->ofl_shdrcnt.
348  *
349  * As new sections are placed, ofl->ofl_shdrcnt is incremented to
350  * track the count. If -z ignore is not in effect, then this is
351  * sufficient. If -z ignore is in effect however, the sections that
352  * are removed are not reflected in the value of ofl->ofl_shdrcnt.
353  * Determining whether ofl->ofl_shdrcnt should get decremented in
354  * that situation  takes some work to determine, and if multiple
355  * sections are discarded (which is typical), then it would be
356  * necessary to do that work each time. Instead, we use this
357  * routine to recompute the number of output sections once at the end.
358  */
359 void
360 ld_recalc_shdrcnt(Ofl_desc *ofl)
361 {
362 	Sg_desc		*sgp;
363 	Listnode	*lnp1, *lnp2;
364 	Word		cnt = 0;
365 	Is_desc *isp;
366 	Os_desc	*osp;
367 	Aliste	idx;
368 
369 
370 	/*
371 	 * This code must be kept in sync with the similar code
372 	 * found in ld_create_outfile().
373 	 *
374 	 * We look at the input sections for every output section,
375 	 * looking for at least one input section that won't
376 	 * be eliminated.
377 	 */
378 	for (LIST_TRAVERSE(&ofl->ofl_segs, lnp1, sgp)) {
379 		Word	ptype = sgp->sg_phdr.p_type;
380 
381 		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx, osp)) {
382 
383 			for (LIST_TRAVERSE(&(osp->os_isdescs), lnp2, isp)) {
384 				Ifl_desc	*ifl = isp->is_file;
385 
386 				/* Input section is tagged for discard? */
387 				if (isp->is_flags & FLG_IS_DISCARD)
388 					continue;
389 
390 				/*
391 				 * If the file is discarded, it will take
392 				 * the section with it.
393 				 */
394 				if (ifl &&
395 				    (((ifl->ifl_flags & FLG_IF_FILEREF) == 0) ||
396 				    ((ptype == PT_LOAD) &&
397 				    ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
398 				    (isp->is_shdr->sh_size > 0))) &&
399 				    (ifl->ifl_flags & FLG_IF_IGNORE))
400 					continue;
401 
402 				/*
403 				 * We have found a kept input section.
404 				 * so the output section will be created.
405 				 */
406 				cnt++;
407 				break;
408 			}
409 		}
410 	}
411 	ofl->ofl_shdrcnt = cnt;
412 }
413 
414 /*
415  * Create the elf structures that allow the input data to be associated with the
416  * new image:
417  *
418  *	o	define the new elf image using elf_begin(),
419  *
420  *	o	obtain an elf header for the image,
421  *
422  *	o	traverse the input segments and create a program header array
423  *		to define the required segments,
424  *
425  *	o 	traverse the output sections for each segment assigning a new
426  *		section descriptor and section header for each,
427  *
428  *	o	traverse the input sections associated with each output section
429  *		and assign a new data descriptor to each (each output section
430  *		becomes a linked list of input data buffers).
431  */
432 uintptr_t
433 ld_create_outfile(Ofl_desc *ofl)
434 {
435 	Listnode	*lnp1;
436 	Sg_desc		*sgp;
437 	Os_desc		*osp;
438 	Is_desc		*isp;
439 	Elf_Data	*tlsdata = 0;
440 	Aliste		idx;
441 	ofl_flag_t	flags = ofl->ofl_flags;
442 	ofl_flag_t	flags1 = ofl->ofl_flags1;
443 	size_t		ndx = 0, fndx = 0;
444 	Elf_Cmd		cmd;
445 	Boolean		fixalign = FALSE;
446 	int		fd, nseg = 0, shidx = 0, dataidx = 0, ptloadidx = 0;
447 
448 	/*
449 	 * If DF_1_NOHDR was set in map_parse() or FLG_OF1_VADDR was set,
450 	 * we need to do alignment adjustment.
451 	 */
452 	if ((flags1 & FLG_OF1_VADDR) ||
453 	    (ofl->ofl_dtflags_1 & DF_1_NOHDR)) {
454 		fixalign = TRUE;
455 	}
456 
457 	if (flags1 & FLG_OF1_MEMORY) {
458 		cmd = ELF_C_IMAGE;
459 		fd = 0;
460 	} else {
461 		fd = ofl->ofl_fd;
462 		cmd = ELF_C_WRITE;
463 	}
464 
465 	/*
466 	 * If there are any ordered sections, handle them here.
467 	 */
468 	if ((ofl->ofl_ordered.head != NULL) &&
469 	    (ld_sort_ordered(ofl) == S_ERROR))
470 		return (S_ERROR);
471 
472 	/*
473 	 * Tell the access library about our new temporary file.
474 	 */
475 	if ((ofl->ofl_welf = elf_begin(fd, cmd, 0)) == NULL) {
476 		eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_BEGIN),
477 		    ofl->ofl_name);
478 		return (S_ERROR);
479 	}
480 
481 	/*
482 	 * Obtain a new Elf header.
483 	 */
484 	if ((ofl->ofl_nehdr = elf_newehdr(ofl->ofl_welf)) == NULL) {
485 		eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_NEWEHDR),
486 		    ofl->ofl_name);
487 		return (S_ERROR);
488 	}
489 	ofl->ofl_nehdr->e_machine = ofl->ofl_dehdr->e_machine;
490 
491 	DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
492 	for (LIST_TRAVERSE(&ofl->ofl_segs, lnp1, sgp)) {
493 		int	frst = 0;
494 		Phdr	*phdr = &(sgp->sg_phdr);
495 		Word	ptype = phdr->p_type;
496 
497 		/*
498 		 * Count the number of segments that will go in the program
499 		 * header table. If a segment is empty, ignore it.
500 		 */
501 		if (!(flags & FLG_OF_RELOBJ)) {
502 			if (ptype == PT_PHDR) {
503 				/*
504 				 * If we are generating an interp section (and
505 				 * thus an associated PT_INTERP program header
506 				 * entry) also generate a PT_PHDR program header
507 				 * entry.  This allows the kernel to generate
508 				 * the appropriate aux vector entries to pass to
509 				 * the interpreter (refer to exec/elf/elf.c).
510 				 * Note that if an image was generated with an
511 				 * interp section, but no associated PT_PHDR
512 				 * program header entry, the kernel will simply
513 				 * pass the interpreter an open file descriptor
514 				 * when the image is executed).
515 				 */
516 				if (ofl->ofl_osinterp)
517 					nseg++;
518 			} else if (ptype == PT_INTERP) {
519 				if (ofl->ofl_osinterp)
520 					nseg++;
521 			} else if (ptype == PT_DYNAMIC) {
522 				if (flags & FLG_OF_DYNAMIC)
523 					nseg++;
524 			} else if (ptype == PT_TLS) {
525 				if (flags & FLG_OF_TLSPHDR)
526 					nseg++;
527 #if	defined(_ELF64)
528 			} else if ((ld_targ.t_m.m_mach == EM_AMD64) &&
529 			    (ptype == PT_SUNW_UNWIND)) {
530 				if (ofl->ofl_unwindhdr)
531 					nseg++;
532 #endif
533 			} else if (ptype == PT_SUNWDTRACE) {
534 				if (ofl->ofl_dtracesym)
535 					nseg++;
536 			} else if (ptype == PT_SUNWCAP) {
537 				if (ofl->ofl_oscap)
538 					nseg++;
539 			} else if (sgp->sg_flags & FLG_SG_EMPTY) {
540 					nseg++;
541 			} else if (sgp->sg_osdescs != NULL) {
542 				if ((sgp->sg_flags & FLG_SG_PHREQ) == 0) {
543 					/*
544 					 * If this is a segment for which
545 					 * we are not making a program header,
546 					 * don't increment nseg
547 					 */
548 					ptype = (sgp->sg_phdr).p_type = PT_NULL;
549 				} else if (ptype != PT_NULL)
550 					nseg++;
551 			}
552 		}
553 
554 		/*
555 		 * If the first loadable segment has the ?N flag,
556 		 * then ?N will be on.
557 		 */
558 		if ((ptype == PT_LOAD) && (ptloadidx == 0)) {
559 			ptloadidx++;
560 			if (sgp->sg_flags & FLG_SG_NOHDR) {
561 				fixalign = TRUE;
562 				ofl->ofl_dtflags_1 |= DF_1_NOHDR;
563 			}
564 		}
565 
566 		shidx = 0;
567 		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx, osp)) {
568 			Listnode	*lnp2;
569 
570 			dataidx = 0;
571 			for (LIST_TRAVERSE(&(osp->os_isdescs), lnp2, isp)) {
572 				Elf_Data *	data;
573 				Ifl_desc *	ifl = isp->is_file;
574 
575 				/*
576 				 * An input section in the list that has
577 				 * been previously marked to be discarded
578 				 * should be completely ignored.
579 				 */
580 				if (isp->is_flags & FLG_IS_DISCARD)
581 					continue;
582 
583 				/*
584 				 * At this point we know whether a section has
585 				 * been referenced.  If it hasn't, and the whole
586 				 * file hasn't been referenced (which would have
587 				 * been caught in ignore_section_processing()),
588 				 * give a diagnostic (-D unused,detail) or
589 				 * discard the section if -zignore is in effect.
590 				 */
591 				if (ifl &&
592 				    (((ifl->ifl_flags & FLG_IF_FILEREF) == 0) ||
593 				    ((ptype == PT_LOAD) &&
594 				    ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
595 				    (isp->is_shdr->sh_size > 0)))) {
596 					Lm_list	*lml = ofl->ofl_lml;
597 
598 					if (ifl->ifl_flags & FLG_IF_IGNORE) {
599 						isp->is_flags |= FLG_IS_DISCARD;
600 						DBG_CALL(Dbg_unused_sec(lml,
601 						    isp));
602 						continue;
603 					} else {
604 						DBG_CALL(Dbg_unused_sec(lml,
605 						    isp));
606 					}
607 				}
608 
609 				/*
610 				 * If this section provides no data, and isn't
611 				 * referenced, then it can be discarded as well.
612 				 * Note, if this is the first input section
613 				 * associated to an output section, let it
614 				 * through, there may be a legitimate reason why
615 				 * the user wants a null section.  Discarding
616 				 * additional sections is intended to remove the
617 				 * empty clutter the compilers have a habit of
618 				 * creating.  Don't provide an unused diagnostic
619 				 * as these sections aren't typically the users
620 				 * creation.
621 				 */
622 				if (ifl && dataidx &&
623 				    ((isp->is_flags & FLG_IS_SECTREF) == 0) &&
624 				    (isp->is_shdr->sh_size == 0)) {
625 					isp->is_flags |= FLG_IS_DISCARD;
626 					continue;
627 				}
628 
629 				/*
630 				 * The first input section triggers the creation
631 				 * of the associated output section.
632 				 */
633 				if (osp->os_scn == NULL) {
634 					shidx++;
635 
636 					if (create_outsec(ofl, sgp, osp, ptype,
637 					    shidx, fixalign) == S_ERROR)
638 						return (S_ERROR);
639 				}
640 
641 				dataidx++;
642 
643 				/*
644 				 * Create a new output data buffer for each
645 				 * input data buffer, thus linking the new
646 				 * buffers to the new elf output structures.
647 				 * Simply make the new data buffers point to
648 				 * the old data.
649 				 */
650 				if ((data = elf_newdata(osp->os_scn)) == NULL) {
651 					eprintf(ofl->ofl_lml, ERR_ELF,
652 					    MSG_INTL(MSG_ELF_NEWDATA),
653 					    ofl->ofl_name);
654 					return (S_ERROR);
655 				}
656 				*data = *(isp->is_indata);
657 				isp->is_indata = data;
658 
659 				if ((fixalign == TRUE) && (ptype == PT_LOAD) &&
660 				    (shidx == 1) && (dataidx == 1))
661 					data->d_align = sgp->sg_addralign;
662 
663 				/*
664 				 * Save the first TLS data buffer, as this is
665 				 * the start of the TLS segment. Realign this
666 				 * buffer based on the alignment requirements
667 				 * of all the TLS input sections.
668 				 */
669 				if ((flags & FLG_OF_TLSPHDR) &&
670 				    (isp->is_shdr->sh_flags & SHF_TLS)) {
671 					if (tlsdata == 0)
672 						tlsdata = data;
673 					tlsdata->d_align =
674 					    ld_lcm(tlsdata->d_align,
675 					    isp->is_shdr->sh_addralign);
676 				}
677 
678 #if	defined(_ELF64) && defined(_ILP32)
679 				/*
680 				 * 4106312, the 32-bit ELF64 version of ld
681 				 * needs to be able to create large .bss
682 				 * sections.  The d_size member of Elf_Data
683 				 * only allows 32-bits in _ILP32, so we build
684 				 * multiple data-items that each fit into 32-
685 				 * bits.  libelf (4106398) can summ these up
686 				 * into a 64-bit quantity.  This only works
687 				 * for NOBITS sections which don't have any
688 				 * real data to maintain and don't require
689 				 * large file support.
690 				 */
691 				if (isp->is_shdr->sh_type == SHT_NOBITS) {
692 					Xword sz = isp->is_shdr->sh_size;
693 
694 					while (sz >> 32) {
695 						data->d_size = SIZE_MAX;
696 						sz -= (Xword)SIZE_MAX;
697 
698 						data = elf_newdata(osp->os_scn);
699 						if (data == NULL)
700 							return (S_ERROR);
701 					}
702 					data->d_size = (size_t)sz;
703 				}
704 #endif
705 
706 				/*
707 				 * If this segment requires rounding realign the
708 				 * first data buffer associated with the first
709 				 * section.
710 				 */
711 				if ((frst++ == 0) &&
712 				    (sgp->sg_flags & FLG_SG_ROUND)) {
713 					Xword    align;
714 
715 					if (data->d_align)
716 						align = (Xword)
717 						    S_ROUND(data->d_align,
718 						    sgp->sg_round);
719 					else
720 						align = sgp->sg_round;
721 
722 					data->d_align = (size_t)align;
723 				}
724 			}
725 
726 			/*
727 			 * Clear the szoutrels counter so that it can be used
728 			 * again in the building of relocs.  See machrel.c.
729 			 */
730 			osp->os_szoutrels = 0;
731 		}
732 	}
733 
734 	/*
735 	 * Build an empty PHDR.
736 	 */
737 	if (nseg) {
738 		if ((ofl->ofl_phdr = elf_newphdr(ofl->ofl_welf,
739 		    nseg)) == NULL) {
740 			eprintf(ofl->ofl_lml, ERR_ELF,
741 			    MSG_INTL(MSG_ELF_NEWPHDR), ofl->ofl_name);
742 			return (S_ERROR);
743 		}
744 	}
745 
746 	/*
747 	 * If we need to generate a memory model, pad the image.
748 	 */
749 	if (flags1 & FLG_OF1_MEMORY) {
750 		if (pad_outfile(ofl) == S_ERROR)
751 			return (S_ERROR);
752 	}
753 
754 	/*
755 	 * After all the basic input file processing, all data pointers are
756 	 * referencing two types of memory:
757 	 *
758 	 *	o	allocated memory, ie. elf structures, internal link
759 	 *		editor structures, and any new sections that have been
760 	 *		created.
761 	 *
762 	 *	o	original input file mmap'ed memory, ie. the actual data
763 	 *		sections of the input file images.
764 	 *
765 	 * Up until now, the only memory modifications have been carried out on
766 	 * the allocated memory.  Before carrying out any relocations, write the
767 	 * new output file image and reassign any necessary data pointers to the
768 	 * output files memory image.  This insures that any relocation
769 	 * modifications are made to the output file image and not to the input
770 	 * file image, thus preventing the creation of dirty pages and reducing
771 	 * the overall swap space requirement.
772 	 *
773 	 * Write out the elf structure so as to create the new file image.
774 	 */
775 	if ((ofl->ofl_size = (size_t)elf_update(ofl->ofl_welf,
776 	    ELF_C_WRIMAGE)) == (size_t)-1) {
777 		eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_UPDATE),
778 		    ofl->ofl_name);
779 		return (S_ERROR);
780 	}
781 
782 	/*
783 	 * Initialize the true `ofl' information with the memory images address
784 	 * and size.  This will be used to write() out the image once any
785 	 * relocation processing has been completed.  We also use this image
786 	 * information to setup a new Elf descriptor, which is used to obtain
787 	 * all the necessary elf pointers within the new output image.
788 	 */
789 	if ((ofl->ofl_elf = elf_begin(0, ELF_C_IMAGE,
790 	    ofl->ofl_welf)) == NULL) {
791 		eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_BEGIN),
792 		    ofl->ofl_name);
793 		return (S_ERROR);
794 	}
795 	if ((ofl->ofl_nehdr = elf_getehdr(ofl->ofl_elf)) == NULL) {
796 		eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETEHDR),
797 		    ofl->ofl_name);
798 		return (S_ERROR);
799 	}
800 	if (!(flags & FLG_OF_RELOBJ))
801 		if ((ofl->ofl_phdr = elf_getphdr(ofl->ofl_elf)) == NULL) {
802 			eprintf(ofl->ofl_lml, ERR_ELF,
803 			    MSG_INTL(MSG_ELF_GETPHDR), ofl->ofl_name);
804 			return (S_ERROR);
805 		}
806 
807 	/*
808 	 * Reinitialize the section descriptors, section headers and obtain new
809 	 * output data buffer pointers (these will be used to perform any
810 	 * relocations).
811 	 */
812 	for (LIST_TRAVERSE(&ofl->ofl_segs, lnp1, sgp)) {
813 		Phdr	*_phdr = &(sgp->sg_phdr);
814 		Os_desc	*osp;
815 		Aliste	idx;
816 		Boolean	recorded = FALSE;
817 
818 		for (APLIST_TRAVERSE(sgp->sg_osdescs, idx, osp)) {
819 			/*
820 			 * Make sure that an output section was originally
821 			 * created.  Input sections that had been marked as
822 			 * discarded may have made an output section
823 			 * unnecessary.  Remove this alist entry so that
824 			 * future output section descriptor processing doesn't
825 			 * have to compensate for this empty section.
826 			 */
827 			if (osp->os_scn == NULL) {
828 				aplist_delete(sgp->sg_osdescs, &idx);
829 				continue;
830 			}
831 
832 			if ((osp->os_scn = elf_getscn(ofl->ofl_elf, ++ndx)) ==
833 			    NULL) {
834 				eprintf(ofl->ofl_lml, ERR_ELF,
835 				    MSG_INTL(MSG_ELF_GETSCN), ofl->ofl_name,
836 				    ndx);
837 				return (S_ERROR);
838 			}
839 			if ((osp->os_shdr = elf_getshdr(osp->os_scn)) ==
840 			    NULL) {
841 				eprintf(ofl->ofl_lml, ERR_ELF,
842 				    MSG_INTL(MSG_ELF_GETSHDR), ofl->ofl_name);
843 				return (S_ERROR);
844 			}
845 			if ((fixalign == TRUE) && (sgp->sg_fscn != 0) &&
846 			    (recorded == FALSE)) {
847 				Elf_Scn *scn;
848 
849 				scn = sgp->sg_fscn;
850 				if ((fndx = elf_ndxscn(scn)) == SHN_UNDEF) {
851 					eprintf(ofl->ofl_lml, ERR_ELF,
852 					    MSG_INTL(MSG_ELF_NDXSCN),
853 					    ofl->ofl_name);
854 					return (S_ERROR);
855 				}
856 				if (ndx == fndx) {
857 					sgp->sg_fscn = osp->os_scn;
858 					recorded = TRUE;
859 				}
860 			}
861 
862 			if ((osp->os_outdata =
863 			    elf_getdata(osp->os_scn, NULL)) == NULL) {
864 				eprintf(ofl->ofl_lml, ERR_ELF,
865 				    MSG_INTL(MSG_ELF_GETDATA), ofl->ofl_name);
866 				return (S_ERROR);
867 			}
868 
869 			/*
870 			 * If this section is part of a loadable segment insure
871 			 * that the segments alignment is appropriate.
872 			 */
873 			if (_phdr->p_type == PT_LOAD) {
874 				_phdr->p_align = ld_lcm(_phdr->p_align,
875 				    osp->os_shdr->sh_addralign);
876 			}
877 		}
878 	}
879 	return (1);
880 }
881