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