| blob | d731e935d4e9ce91494bb178715eef6153b9a7ea |
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 */
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 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
28 */
30 /*
31 * Processing of relocatable objects and shared objects.
32 */
34 #define ELF_TARGET_AMD64
35 #define ELF_TARGET_SPARC
37 #include <stdio.h>
38 #include <string.h>
39 #include <fcntl.h>
40 #include <unistd.h>
41 #include <link.h>
42 #include <limits.h>
43 #include <sys/stat.h>
44 #include <sys/systeminfo.h>
45 #include <debug.h>
46 #include <msg.h>
47 #include <_libld.h>
49 /*
50 * Decide if we can link against this input file.
51 */
52 static int
54 {
55 /*
56 * Check the validity of the elf header information for compatibility
57 * with this machine and our own internal elf library.
58 */
65 }
70 }
75 }
77 }
79 /*
80 * Check sanity of file header and allocate an infile descriptor
81 * for the file being processed.
82 */
86 {
97 }
99 }
108 /*
109 * Is this file using 'extended Section Indexes'. If so, use the
110 * e_shnum & e_shstrndx which can be found at:
111 *
112 * e_shnum == Shdr[0].sh_size
113 * e_shstrndx == Shdr[0].sh_link
114 */
121 name);
123 }
126 name);
128 }
132 else
137 }
143 /*
144 * Record this new input file on the shared object or relocatable
145 * object input file list.
146 */
153 }
156 }
158 /*
159 * Process a generic section. The appropriate section information is added
160 * to the files input descriptor list.
161 */
162 static uintptr_t
165 {
168 /*
169 * Create a new input section descriptor. If this is a NOBITS
170 * section elf_getdata() will still create a data buffer (the buffer
171 * will be null and the size will reflect the actual memory size).
172 */
186 }
191 }
193 /*
194 * Add the new input section to the files input section list and
195 * flag whether the section needs placing in an output section. This
196 * placement is deferred until all input section processing has been
197 * completed, as SHT_GROUP sections can provide information that will
198 * affect how other sections within the file should be placed.
199 */
206 }
208 }
210 }
212 /*
213 * Determine the software capabilities of the object being built from the
214 * capabilities of the input relocatable objects. One software capability
215 * is presently recognized, and represented with the following (sys/elf.h):
216 *
217 * SF1_SUNW_FPKNWN use/non-use of frame pointer is known, and
218 * SF1_SUNW_FPUSED the frame pointer is in use.
219 *
220 * The resolution of the present fame pointer state, and the capabilities
221 * provided by a new input relocatable object are:
222 *
223 * new input relocatable object
224 *
225 * present | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | <unknown>
226 * state | SF1_SUNW_FPUSED | |
227 * ---------------------------------------------------------------------------
228 * SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN
229 * SF1_SUNW_FPUSED | SF1_SUNW_FPUSED | | SF1_SUNW_FPUSED
230 * ---------------------------------------------------------------------------
231 * SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN
232 * | | |
233 * ---------------------------------------------------------------------------
234 * <unknown> | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | <unknown>
235 * | SF1_SUNW_FPUSED | |
236 */
237 static void
239 {
240 #define FP_FLAGS (SF1_SUNW_FPKNWN | SF1_SUNW_FPUSED)
242 Xword badval;
244 /*
245 * If a mapfile has established definitions to override any object
246 * capabilities, ignore any new object capabilities.
247 */
252 }
254 #if !defined(_ELF64)
256 /*
257 * The SF1_SUNW_ADDR32 is only meaningful when building a 64-bit
258 * object. Warn the user, and remove the setting, if we're
259 * building a 32-bit object.
260 */
266 }
267 }
268 #endif
269 /*
270 * If this object doesn't specify any capabilities, ignore it, and
271 * leave the state as is.
272 */
276 /*
277 * Make sure we only accept known software capabilities. Note, that
278 * an F1_SUNW_FPUSED by itself is viewed as bad practice.
279 */
285 }
291 }
293 /*
294 * If the input file is not a relocatable object, then we're only here
295 * to warn the user of any questionable capabilities.
296 */
298 #if defined(_ELF64)
299 /*
300 * If we're building a 64-bit executable, and we come across a
301 * dependency that requires a restricted address space, then
302 * that dependencies requirement can only be satisfied if the
303 * executable triggers the restricted address space. This is a
304 * warning rather than a fatal error, as the possibility exists
305 * that an appropriate dependency will be provided at runtime.
306 * The runtime linker will refuse to use this dependency.
307 */
314 }
315 #endif
317 }
324 }
326 /*
327 * Determine the resolution of the present frame pointer and the
328 * new input relocatable objects frame pointer.
329 */
331 /*
332 * If the new relocatable object isn't using a frame pointer,
333 * reduce the present state to unused.
334 */
338 /*
339 * Having processed the frame pointer bits, remove them from
340 * the value so they don't get OR'd in below.
341 */
345 /*
346 * If the present frame pointer state is unknown, mask it out
347 * and allow the values from the new relocatable object
348 * to overwrite them.
349 */
352 /* Do not take the frame pointer flags from the object */
354 }
361 #undef FP_FLAGS
362 }
364 /*
365 * Determine the hardware capabilities of the object being built from the
366 * capabilities of the input relocatable objects. There's really little to
367 * do here, other than to offer diagnostics, hardware capabilities are simply
368 * additive.
369 */
370 static void
372 {
374 ofl_flag_t flags1;
382 }
384 /*
385 * If a mapfile has established definitions to override any object
386 * capabilities, ignore any new object capabilities.
387 */
392 }
394 /*
395 * If this object doesn't specify any capabilities, ignore it, and
396 * leave the state as is.
397 */
406 }
412 }
414 /*
415 * Promote a machine capability or platform capability to the output file.
416 * Multiple instances of these names can be defined.
417 */
418 static void
420 {
422 Aliste idx;
425 /*
426 * If a mapfile has established definitions to override this capability,
427 * ignore any new capability.
428 */
433 }
440 }
449 }
451 }
457 }
458 }
459 }
461 /*
462 * Promote a capability identifier to the output file. A capability group can
463 * only have one identifier, and thus only the first identifier seen from any
464 * input relocatable objects is retained. An explicit user defined identifier,
465 * rather than an an identifier fabricated by ld(1) with -z symbcap processing,
466 * takes precedence. Note, a user may have defined an identifier via a mapfile,
467 * in which case the mapfile identifier is retained.
468 */
469 static void
471 {
483 }
484 }
494 }
496 /*
497 * Promote a capabilities group to the object capabilities. This catches a
498 * corner case. An object capabilities file can be converted to symbol
499 * capabilities with -z symbolcap. However, if the user has indicated that all
500 * the symbols should be demoted, we'd be left with a symbol capabilities file,
501 * with no associated symbols. Catch this case by promoting the symbol
502 * capabilities back to object capabilities.
503 */
504 void
506 {
508 Aliste idx1;
513 Aliste idx2;
519 }
522 capstr)) {
525 }
526 }
529 capstr)) {
532 }
533 }
542 }
543 }
545 /*
546 * Determine whether a capabilities group already exists that describes this
547 * new capabilities group.
548 *
549 * Note, a capability group identifier, CA_SUNW_ID, isn't used as part of the
550 * comparison. This attribute simply assigns a diagnostic name to the group,
551 * and in the case of multiple identifiers, the first will be taken.
552 */
555 {
556 Aliste idx;
560 /*
561 * If the new capabilities contains a CA_SUNW_ID, drop the count of the
562 * number of comparable items.
563 */
565 ccnum--;
567 /*
568 * Traverse the existing symbols capabilities groups.
569 */
575 onum--;
601 /*
602 * If a matching group is found, then this new group has
603 * already been supplied by a previous file, and hence the
604 * existing group can be used. Record this new input section,
605 * from which we can also derive the input file name, on the
606 * existing groups input sections.
607 */
612 }
614 /*
615 * If a capabilities group is not found, create a new one.
616 */
622 /*
623 * If we're converting object capabilities to symbol capabilities and
624 * no CA_SUNW_ID is defined, fabricate one. This identifier is appended
625 * to all symbol names that are converted into capabilities symbols,
626 * see ld_sym_process().
627 */
632 /*
633 * Create an identifier using the group number together with a
634 * default template. We allocate a buffer large enough for any
635 * possible number of items (way more than we need).
636 */
644 cnum++;
645 }
650 /*
651 * Null the callers alist's as they've effectively been transferred
652 * to this new Cap_group.
653 */
656 /*
657 * Keep track of which input section, and hence input file, established
658 * this group.
659 */
663 /*
664 * Keep track of the number of symbol capabilities entries that will be
665 * required in the output file. Each group requires a terminating
666 * CA_SUNW_NULL.
667 */
670 }
672 /*
673 * Capture symbol capability family information. This data structure is focal
674 * in maintaining all symbol capability relationships, and provides for the
675 * eventual creation of a capabilities information section, and possibly a
676 * capabilities chain section.
677 *
678 * Capabilities families are lead by a CAPINFO_SUNW_GLOB symbol. This symbol
679 * provides the visible global symbol that is referenced by all external
680 * callers. This symbol may have aliases. For example, a weak/global symbol
681 * pair, such as memcpy()/_memcpy() may lead the same capabilities family.
682 * Each family contains one or more local symbol members. These members provide
683 * the capabilities specific functions, and are associated to a capabilities
684 * group. For example, the capability members memcpy%sun4u and memcpy%sun4v
685 * might be associated with the memcpy() capability family.
686 *
687 * This routine is called when a relocatable object that provides object
688 * capabilities is transformed into a symbol capabilities object, using the
689 * -z symbolcap option.
690 *
691 * This routine is also called to collect the SUNW_capinfo section information
692 * of a relocatable object that contains symbol capability definitions.
693 */
694 uintptr_t
697 {
702 Aliste idx;
704 /*
705 * Make sure the capability families have an initialized AVL tree.
706 */
714 /*
715 * When creating a dynamic object, capability family members
716 * are maintained in a .SUNW_capchain, the first entry of
717 * which is the version number of the chain.
718 */
720 }
722 /*
723 * Determine whether a family already exists, and if not, create one
724 * using the lead family symbol.
725 */
738 /*
739 * When creating a dynamic object, capability family members
740 * are maintained in a .SUNW_capchain, each family starts with
741 * this lead symbol, and is terminated with a 0 element.
742 */
744 }
746 /*
747 * If no group information is provided then this request is to add a
748 * lead capability symbol, or lead symbol alias. If this is the lead
749 * symbol there's nothing more to do. Otherwise save the alias.
750 */
757 }
759 /*
760 * Determine whether a member of the same group as this new member is
761 * already defined within this family. If so, we have a multiply
762 * defined symbol.
763 */
770 /*
771 * Diagnose that a multiple symbol definition exists.
772 */
780 }
782 /*
783 * Add this capabilities symbol member to the family.
784 */
792 /*
793 * When creating a dynamic object, capability family members are
794 * maintained in a .SUNW_capchain. Account for this family member.
795 */
798 /*
799 * If this input file is undergoing object capabilities to symbol
800 * capabilities conversion, then this member is a new local symbol
801 * that has been generated from an original global symbol. Keep track
802 * of this symbol so that the output file symbol table can be populated
803 * with these new symbol entries.
804 */
809 }
811 /*
812 * Process a SHT_SUNW_cap capabilities section.
813 */
814 static uintptr_t
816 {
825 /*
826 * Determine the capabilities data and size.
827 */
836 /*
837 * Traverse the section to determine what capabilities groups are
838 * available.
839 *
840 * A capabilities section can contain one or more, CA_SUNW_NULL
841 * terminated groups.
842 *
843 * - The first group defines the object capabilities.
844 * - Additional groups define symbol capabilities.
845 * - Since the initial group is always reserved for object
846 * capabilities, any object with symbol capabilities must also
847 * have an object capabilities group. If the object has no object
848 * capabilities, an empty object group is defined, consisting of a
849 * CA_SUNW_NULL element in index [0].
850 * - If any capabilities require references to a named string, then
851 * the section header sh_info points to the associated string
852 * table.
853 * - If an object contains symbol capability groups, then the
854 * section header sh_link points to the associated capinfo table.
855 */
863 /*
864 * If this is the first CA_SUNW_NULL entry, and no
865 * capabilities group has been found, then this object
866 * does not define any object capabilities.
867 */
879 capstrs++;
880 /* FALLTHROUGH */
885 /*
886 * If this is the start of a new group, save it.
887 */
896 }
897 }
899 /*
900 * If a string capabilities entry has been found, the capabilities
901 * section must reference the associated string table.
902 */
911 }
913 }
915 /*
916 * The processing of capabilities groups is as follows:
917 *
918 * - if a relocatable object provides only object capabilities, and
919 * the -z symbolcap option is in effect, then the object
920 * capabilities are transformed into symbol capabilities and the
921 * symbol capabilities are carried over to the output file.
922 * - in all other cases, any capabilities present in an input
923 * relocatable object are carried from the input object to the
924 * output without any transformation or conversion.
925 *
926 * Capture any object capabilities that are to be carried over to the
927 * output file.
928 */
932 /*
933 * Object capabilities end at the first null.
934 */
938 /*
939 * Only the object software capabilities that are
940 * defined in a relocatable object become part of the
941 * object software capabilities in the output file.
942 * However, check the validity of any object software
943 * capabilities of any dependencies.
944 */
948 }
950 /*
951 * The remaining capability types must come from a
952 * relocatable object in order to contribute to the
953 * output.
954 */
978 FLG_OCS_USRDEFID);
983 }
984 }
986 /*
987 * If there are no symbol capabilities, or this objects
988 * capabilities aren't being transformed into a symbol
989 * capabilities, then we're done.
990 */
994 }
996 /*
997 * If these capabilities don't originate from a relocatable object
998 * there's no further processing required.
999 */
1003 /*
1004 * If this object only defines an object capabilities group, and the
1005 * -z symbolcap option is in effect, then all global function symbols
1006 * and initialized global data symbols are renamed and assigned to the
1007 * transformed symbol capabilities group.
1008 */
1013 /*
1014 * Allocate a capabilities descriptor to collect the capabilities data
1015 * for this input file. Allocate a mirror of the raw capabilities data
1016 * that points to the individual symbol capabilities groups. An APlist
1017 * is used, although it will be sparsely populated, as the list provides
1018 * a convenient mechanism for traversal later.
1019 */
1024 /*
1025 * Clear the allocated APlist data array, and assign the number of
1026 * items as the total number of array items.
1027 */
1034 /*
1035 * Traverse the capabilities data, unpacking the data into a
1036 * capabilities set. Process each capabilities set as a unique group.
1037 */
1046 nulls++;
1048 /*
1049 * Process the capabilities group that this null entry
1050 * terminates. The capabilities group that is returned
1051 * will either point to this file's data, or to a
1052 * matching capabilities group that has already been
1053 * processed.
1054 *
1055 * Note, if this object defines object capabilities,
1056 * the first group descriptor points to these object
1057 * capabilities. It is only necessary to save this
1058 * descriptor when object capabilities are being
1059 * transformed into symbol capabilities (-z symbolcap).
1060 */
1071 }
1073 /*
1074 * Clean up the capabilities data in preparation
1075 * for processing additional groups. If the
1076 * collected capabilities strings were used to
1077 * establish a new output group, they will have
1078 * been saved in get_cap_group(). If these
1079 * descriptors still exist, then an existing
1080 * descriptor has been used to associate with
1081 * this file, and these string descriptors can
1082 * be freed.
1083 */
1090 }
1094 }
1096 }
1144 }
1146 /*
1147 * Save the start of this new group.
1148 */
1151 }
1153 }
1155 /*
1156 * Capture any symbol capabilities symbols. An object file that contains symbol
1157 * capabilities has an associated .SUNW_capinfo section. This section
1158 * identifies which symbols are associated to which capabilities, together with
1159 * their associated lead symbol. Each of these symbol pairs are recorded for
1160 * processing later.
1161 */
1162 static uintptr_t
1164 {
1177 Word lndx;
1178 uchar_t gndx;
1184 /*
1185 * Catch any anomalies. A capabilities symbol should be valid,
1186 * and the capabilities lead symbol should also be global.
1187 * Note, ld(1) -z symbolcap would create local capabilities
1188 * symbols, but we don't enforce this so as to give the
1189 * compilation environment a little more freedom.
1190 */
1197 }
1205 lndx);
1207 }
1209 /*
1210 * Indicate that this is a capabilities symbol.
1211 */
1214 /*
1215 * Save any global capability symbols. Global capability
1216 * symbols are identified with a CAPINFO_SUNW_GLOB group id.
1217 * The lead symbol for this global capability symbol is either
1218 * the symbol itself, or an alias.
1219 */
1225 }
1227 /*
1228 * Track the number of non-global capabilities symbols, as these
1229 * are used to size any symbol tables. If we're generating a
1230 * dynamic object, this symbol will be added to the dynamic
1231 * symbol table, therefore ensure there is space in the dynamic
1232 * string table.
1233 */
1239 /*
1240 * As we're tracking this local symbol as a capabilities symbol,
1241 * reduce the local symbol count to compensate.
1242 */
1245 /*
1246 * Determine whether the associated lead symbol indicates
1247 * NODYNSORT. If so, remove this local entry from the
1248 * SUNW_dynsort section too. NODYNSORT tagging can only be
1249 * obtained from a mapfile symbol definition, and thus any
1250 * global definition that has this tagging has already been
1251 * instantiated and this instance resolved to it.
1252 */
1259 }
1261 /*
1262 * Track this family member, together with its associated group.
1263 */
1267 }
1270 }
1272 /*
1273 * Simply process the section so that we have pointers to the data for use
1274 * in later routines, however don't add the section to the output section
1275 * list as we will be creating our own replacement sections later (ie.
1276 * symtab and relocation).
1277 */
1278 static uintptr_t
1279 /* ARGSUSED5 */
1282 {
1285 }
1287 /*
1288 * Keep a running count of relocation entries from input relocatable objects for
1289 * sizing relocation buckets later. If we're building an executable, save any
1290 * relocations from shared objects to determine if any copy relocation symbol
1291 * has a displacement relocation against it.
1292 */
1293 static uintptr_t
1294 /* ARGSUSED5 */
1297 {
1304 /* LINTED */
1311 }
1313 }
1315 /*
1316 * Process a string table section. A valid section contains an initial and
1317 * final null byte.
1318 */
1319 static uintptr_t
1322 {
1328 /*
1329 * Never include .stab.excl sections in any output file.
1330 * If the -s flag has been specified strip any .stab sections.
1331 */
1337 /*
1338 * If we got here to process a .shstrtab or .dynstr table, `ident' will
1339 * be null. Otherwise make sure we don't have a .strtab section as this
1340 * should not be added to the output section list either.
1341 */
1350 /*
1351 * String tables should start and end with a NULL byte. Note, it has
1352 * been known for the assembler to create empty string tables, so check
1353 * the size before attempting to verify the data itself.
1354 */
1368 }
1370 /*
1371 * Invalid sections produce a warning and are skipped.
1372 */
1373 static uintptr_t
1374 /* ARGSUSED3 */
1377 {
1378 Conv_inv_buf_t inv_buf;
1385 }
1387 /*
1388 * Compare an input section name to a given string, taking the ELF '%'
1389 * section naming convention into account. If an input section name
1390 * contains a '%' character, the '%' and all following characters are
1391 * ignored in the comparison.
1392 *
1393 * entry:
1394 * is_name - Name of input section
1395 * match_name - Name to compare to
1396 * match_len - strlen(match_name)
1397 *
1398 * exit:
1399 * Returns True (1) if the names match, and False (0) otherwise.
1400 */
1403 {
1404 /*
1405 * If the start of is_name is not a match for name,
1406 * the match fails.
1407 */
1411 /*
1412 * The prefix matched. The next character must be either '%', or
1413 * NULL, in order for a match to be true.
1414 */
1417 }
1419 /*
1420 * Helper routine for process_progbits() to process allocable sections.
1421 *
1422 * entry:
1423 * name, ifl, shdr, ndx, ident, ofl - As passed to process_progbits().
1424 * is_stab_index - TRUE if section is .index.
1425 * is_flags - Additional flags to be added to the input section.
1426 *
1427 * exit:
1428 * The allocable section has been processed. *ident and *is_flags
1429 * are updated as necessary to reflect the changes. Returns TRUE
1430 * for success, FALSE for failure.
1431 */
1432 /*ARGSUSED*/
1437 {
1444 MSG_SCN_EHFRAME_SIZE))
1451 /*
1452 * Historically, the section containing the logic to
1453 * unwind stack frames -- the .eh_frame section -- was
1454 * of type SHT_PROGBITS. Apparently the most
1455 * aesthetically galling aspect of this was not the
1456 * .eh_frame section's dubious purpose or its filthy
1457 * implementation, but rather its section type; with the
1458 * introduction of the AMD64 ABI, a new section header
1459 * type (SHT_AMD64_UNWIND) was introduced for (and
1460 * dedicated to) this section. When both the Sun
1461 * compilers and the GNU compilers had been modified to
1462 * generate this new section type, the linker became
1463 * much more pedantic about .eh_frame: it refused to
1464 * link an AMD64 object that contained a .eh_frame with
1465 * the legacy SHT_PROGBITS. That this was too fussy is
1466 * evidenced by searching the net for the error message
1467 * that it generated ("section type is SHT_PROGBITS:
1468 * expected SHT_AMD64_UNWIND"), which reveals a myriad
1469 * of problems, including legacy objects, hand-coded
1470 * assembly and otherwise cross-platform objects
1471 * created on other platforms (the GNU toolchain was
1472 * only modified to create the new section type on
1473 * Solaris and derivatives). We therefore always accept
1474 * a .eh_frame of SHT_PROGBITS -- regardless of
1475 * m_sht_unwind.
1476 */
1480 MSG_SCN_GOT_SIZE)) {
1484 }
1487 MSG_SCN_GCC_X_TBL_SIZE)) {
1491 }
1495 MSG_SCN_PLT_SIZE)) {
1498 }
1500 }
1501 }
1504 /*
1505 * This is a work-around for x86 compilers that have
1506 * set SHF_ALLOC for the .stab.index section.
1507 *
1508 * Because of this, make sure that the .stab.index
1509 * does not end up as the last section in the text
1510 * segment. Older linkers can produce segmentation
1511 * violations when they strip (ld -s) against a
1512 * shared object whose last section in the text
1513 * segment is a .stab.
1514 */
1518 }
1519 }
1522 }
1524 /*
1525 * Process a progbits section.
1526 */
1527 static uintptr_t
1530 {
1535 /*
1536 * Never include .stab.excl sections in any output file.
1537 * If the -s flag has been specified strip any .stab sections.
1538 */
1549 }
1556 }
1558 /*
1559 * Update the ident to reflect the type of section we've got.
1560 *
1561 * If there is any .plt or .got section to generate we'll be creating
1562 * our own version, so don't allow any input sections of these types to
1563 * be added to the output section list (why a relocatable object would
1564 * have a .plt or .got is a mystery, but stranger things have occurred).
1565 *
1566 * If there are any unwind sections, and this is a platform that uses
1567 * SHT_PROGBITS for unwind sections, then set their ident to reflect
1568 * that.
1569 */
1582 }
1583 }
1587 /*
1588 * On success, process_section() creates an input section descriptor.
1589 * Now that it exists, we can add any pending input section flags.
1590 */
1595 }
1597 /*
1598 * Handles the SHT_SUNW_{DEBUG,DEBUGSTR) sections.
1599 */
1600 static uintptr_t
1603 {
1604 /*
1605 * Debug information is discarded when the 'ld -s' flag is invoked.
1606 */
1609 }
1611 }
1613 /*
1614 * Process a nobits section.
1615 */
1616 static uintptr_t
1619 {
1623 #if defined(_ELF64)
1627 #endif
1628 else
1630 }
1632 }
1634 /*
1635 * Process a SHT_*_ARRAY section.
1636 */
1637 static uintptr_t
1640 {
1651 }
1653 static uintptr_t
1654 /* ARGSUSED1 */
1656 {
1676 }
1678 /*
1679 * Process a SHT_SYMTAB_SHNDX section.
1680 */
1681 static uintptr_t
1684 {
1688 /*
1689 * Have we already seen the related SYMTAB - if so verify it now.
1690 */
1700 }
1702 }
1704 }
1706 /*
1707 * Final processing for SHT_SYMTAB_SHNDX section.
1708 */
1709 static uintptr_t
1710 /* ARGSUSED2 */
1712 {
1723 }
1725 }
1727 }
1729 /*
1730 * Process .dynamic section from a relocatable object.
1731 *
1732 * Note: That the .dynamic section is only considered interesting when
1733 * dlopen()ing a relocatable object (thus FLG_OF1_RELDYN can only get
1734 * set when libld is called from ld.so.1).
1735 */
1736 /*ARGSUSED*/
1737 static uintptr_t
1740 {
1746 /*
1747 * Process .dynamic sections from relocatable objects ?
1748 */
1752 /*
1753 * Find the string section associated with the .dynamic section.
1754 */
1759 }
1763 /*
1764 * And get the .dynamic data
1765 */
1792 /*
1793 * The Solaris ld does not put DT_VERSYM in the
1794 * dynamic section. If the object has DT_VERSYM,
1795 * then it must have been produced by the GNU ld,
1796 * and is using the GNU style of versioning.
1797 */
1800 }
1801 }
1803 }
1805 /*
1806 * Expand implicit references. Dependencies can be specified in terms of the
1807 * $ORIGIN, $MACHINE, $PLATFORM, $OSREL and $OSNAME tokens, either from their
1808 * needed name, or via a runpath. In addition runpaths may also specify the
1809 * $ISALIST token.
1810 *
1811 * Probably the most common reference to explicit dependencies (via -L) will be
1812 * sufficient to find any associated implicit dependencies, but just in case we
1813 * expand any occurrence of these known tokens here.
1814 *
1815 * Note, if any errors occur we simply return the original name.
1816 *
1817 * This code is remarkably similar to expand() in rtld/common/paths.c.
1818 */
1828 {
1844 }
1852 /*
1853 * For $ORIGIN, expansion is really just a concatenation
1854 * of the parents directory name. For example, an
1855 * explicit dependency foo/bar/lib1.so with a dependency
1856 * on $ORIGIN/lib2.so would be expanded to
1857 * foo/bar/lib2.so.
1858 */
1861 nrem--;
1871 }
1877 /*
1878 * Establish the machine from sysconf - like uname -i.
1879 */
1891 }
1902 }
1906 /*
1907 * Establish the platform from sysconf - like uname -i.
1908 */
1920 }
1931 }
1935 /*
1936 * Establish the os name - like uname -s.
1937 */
1952 }
1956 /*
1957 * Establish the os release - like uname -r.
1958 */
1973 }
1977 /*
1978 * Establish instruction sets from sysconf. Note that
1979 * this is only meaningful from runpaths.
1980 */
2001 /*
2002 * As ISALIST expands to a number of elements,
2003 * establish a new list to return to the caller.
2004 * This will contain the present path being
2005 * processed redefined for each isalist option,
2006 * plus the original remaining list entries.
2007 */
2025 }
2028 else
2030 }
2031 }
2033 /*
2034 * If no expansion occurred skip the $ and continue.
2035 */
2038 }
2040 /*
2041 * If any ISALIST processing has occurred not only do we return the
2042 * expanded node we're presently working on, but we must also update the
2043 * remaining list so that it is effectively prepended with this node
2044 * expanded to all remaining isalist options. Note that we can only
2045 * handle one ISALIST per node. For more than one ISALIST to be
2046 * processed we'd need a better algorithm than above to replace the
2047 * newly generated list. Whether we want to encourage the number of
2048 * pathname permutations this would provide is another question. So, for
2049 * now if more than one ISALIST is encountered we return the original
2050 * node untouched.
2051 */
2055 else
2057 }
2066 }
2068 }
2070 /*
2071 * The Solaris ld does not put DT_VERSYM in the dynamic section, but the
2072 * GNU ld does, and it is used by the runtime linker to implement their
2073 * versioning scheme. Use this fact to determine if the sharable object
2074 * was produced by the GNU ld rather than the Solaris one, and to set
2075 * FLG_IF_GNUVER if so. This needs to be done before the symbols are
2076 * processed, since the answer determines whether we interpret the
2077 * symbols versions according to Solaris or GNU rules.
2078 */
2079 /*ARGSUSED*/
2080 static uintptr_t
2083 {
2092 /* Get the .dynamic data */
2099 }
2100 }
2102 }
2104 /*
2105 * Process a dynamic section. If we are processing an explicit shared object
2106 * then we need to determine if it has a recorded SONAME, if so, this name will
2107 * be recorded in the output file being generated as the NEEDED entry rather
2108 * than the shared objects filename itself.
2109 * If the mode of the link-edit indicates that no undefined symbols should
2110 * remain, then we also need to build up a list of any additional shared object
2111 * dependencies this object may have. In this case save any NEEDED entries
2112 * together with any associated run-path specifications. This information is
2113 * recorded on the `ofl_soneed' list and will be analyzed after all explicit
2114 * file processing has been completed (refer finish_libs()).
2115 */
2116 static uintptr_t
2118 {
2122 Boolean no_undef;
2127 /* Determine if we need to examine the runpaths and NEEDED entries */
2131 /*
2132 * First loop through the dynamic section looking for a run path.
2133 */
2142 }
2143 }
2145 /*
2146 * Now look for any needed dependencies (which may use the rpath)
2147 * or a new SONAME.
2148 */
2154 /*
2155 * Update the input file structure with this new name.
2156 */
2168 /*
2169 * Determine if this needed entry is already recorded on
2170 * the shared object needed list, if not create a new
2171 * definition for later processing (see finish_libs()).
2172 */
2180 }
2182 /*
2183 * Record the runpath (Note that we take the first
2184 * runpath which is exactly what ld.so.1 would do during
2185 * its dependency processing).
2186 */
2200 /*
2201 * If we are building an executable, and this
2202 * dependency is tagged as an interposer, then
2203 * assume that it is required even if symbol
2204 * resolution uncovers no evident use.
2205 *
2206 * If we are building a shared object, then an
2207 * interposer dependency has no special meaning, and we
2208 * treat it as a regular dependency. By definition, all
2209 * interposers must be visible to the runtime linker
2210 * at initialization time, and cannot be added later.
2211 */
2218 /*
2219 * Record audit string as DT_DEPAUDIT.
2220 */
2227 /*
2228 * If this dependency has the DT_SUNW_RTLDINF .dynamic
2229 * entry, then ensure no specialized dependency
2230 * processing is in effect. This tag identifies libc,
2231 * which provides critical startup information (TLS
2232 * routines, threads initialization, etc.) that must
2233 * be exercised as part of process initialization.
2234 */
2237 /*
2238 * libc is not subject to the usual guidance checks
2239 * for lazy loading. It cannot be lazy loaded, libld
2240 * ignores the request, and rtld would ignore the
2241 * setting if it were present.
2242 */
2244 }
2245 }
2247 /*
2248 * Perform some SONAME sanity checks.
2249 */
2252 Aliste idx;
2254 /*
2255 * Determine if anyone else will cause the same SONAME to be
2256 * used (this is either caused by two different files having the
2257 * same SONAME, or by one file SONAME actually matching another
2258 * file basename (if no SONAME is specified within a shared
2259 * library its basename will be used)). Probably rare, but some
2260 * idiot will do it.
2261 */
2267 /*
2268 * Determine the basename of each file. Perhaps
2269 * there are multiple copies of the same file
2270 * being brought in using different -L search
2271 * paths, and if so give an extra hint in the
2272 * error message.
2273 */
2277 else
2278 iflb++;
2283 else
2284 siflb++;
2288 else
2295 }
2296 }
2298 /*
2299 * If the SONAME is the same as the name the user wishes to
2300 * record when building a dynamic library (refer -h option),
2301 * we also have a name clash.
2302 */
2309 }
2310 }
2312 }
2314 /*
2315 * Process a progbits section from a relocatable object (ET_REL).
2316 * This is used on non-amd64 objects to recognize .eh_frame sections.
2317 */
2318 /*ARGSUSED1*/
2319 static uintptr_t
2321 {
2327 }
2329 /*
2330 * Process a group section.
2331 */
2332 static uintptr_t
2335 {
2342 /*
2343 * Indicate that this input file has groups to process. Groups are
2344 * processed after all input sections have been processed.
2345 */
2349 }
2351 /*
2352 * Process a relocation entry. At this point all input sections from this
2353 * input file have been assigned an input section descriptor which is saved
2354 * in the `ifl_isdesc' array.
2355 */
2356 static uintptr_t
2358 {
2359 Word rndx;
2363 Conv_inv_buf_t inv_buf;
2365 /*
2366 * Make sure this is a valid relocation we can handle.
2367 */
2374 }
2376 /*
2377 * From the relocation section header information determine which
2378 * section needs the actual relocation. Determine which output section
2379 * this input section has been assigned to and add to its relocation
2380 * list. Note that the relocation section may be null if it is not
2381 * required (ie. .debug, .stabs, etc).
2382 */
2385 /*
2386 * Broken input file.
2387 */
2392 }
2399 /*
2400 * Discard relocations if they are against a section
2401 * which has been discarded.
2402 */
2408 /*
2409 * This section is processed later in
2410 * process_movereloc().
2411 */
2416 }
2422 }
2426 }
2428 }
2430 /*
2431 * SHF_EXCLUDE flags is set for this section.
2432 */
2433 static uintptr_t
2436 {
2437 /*
2438 * Sections SHT_SYMTAB and SHT_DYNDYM, even if SHF_EXCLUDE is on, might
2439 * be needed for ld processing. These sections need to be in the
2440 * internal table. Later it will be determined whether they can be
2441 * eliminated or not.
2442 */
2446 /*
2447 * Other checks
2448 */
2450 /*
2451 * A conflict, issue an warning message, and ignore the section.
2452 */
2456 }
2458 /*
2459 * This sections is not going to the output file.
2460 */
2462 }
2464 /*
2465 * Section processing state table. `Initial' describes the required initial
2466 * procedure to be called (if any), `Final' describes the final processing
2467 * procedure (ie. things that can only be done when all required sections
2468 * have been collected).
2469 */
2474 /* ET_REL ET_DYN */
2495 };
2500 /* ET_REL ET_DYN */
2521 };
2523 #define MAXNDXSIZE 10
2525 /*
2526 * Process an elf file. Each section is compared against the section state
2527 * table to determine whether it should be processed (saved), ignored, or
2528 * is invalid for the type of input file being processed.
2529 */
2530 static uintptr_t
2532 {
2545 /*
2546 * Path information buffer used by ld_place_section() and related
2547 * routines. This information is used to evaluate entrance criteria
2548 * with non-empty file matching lists (ec_files).
2549 */
2552 /*
2553 * First process the .shstrtab section so that later sections can
2554 * reference their name.
2555 */
2563 }
2568 }
2570 NULL) {
2574 }
2580 /*
2581 * Reset the name since the shdr->sh_name could have been changed as
2582 * part of ld_sup_input_section().
2583 */
2585 NULL) {
2589 }
2596 /*
2597 * Determine the state table column from the input file type. Note,
2598 * shared library sections are not added to the output section list.
2599 */
2608 }
2615 ndx++;
2617 /*
2618 * As we've already processed the .shstrtab don't do it again.
2619 */
2627 }
2634 /*
2635 * Reset the name since the shdr->sh_name could have been
2636 * changed as part of ld_sup_input_section().
2637 */
2642 /*
2643 * If the section has the SHF_EXCLUDE flag on, and we're not
2644 * generating a relocatable object, exclude the section.
2645 */
2653 }
2655 /*
2656 * If this is a standard section type process it via the
2657 * appropriate action routine.
2658 */
2664 }
2666 /*
2667 * If this section is below SHT_LOSUNW then we don't
2668 * really know what to do with it, issue a warning
2669 * message but do the basic section processing anyway.
2670 */
2672 Conv_inv_buf_t inv_buf;
2680 }
2682 /*
2683 * Handle sections greater than SHT_LOSUNW.
2684 */
2750 /*
2751 * SHT_SPARC_GOTDATA (0x70000000) is in the
2752 * SHT_LOPROC - SHT_HIPROC range reserved
2753 * for processor-specific semantics. It is
2754 * only meaningful for sparc targets.
2755 */
2763 #if defined(_ELF64)
2765 /*
2766 * SHT_AMD64_UNWIND (0x70000001) is in the
2767 * SHT_LOPROC - SHT_HIPROC range reserved
2768 * for processor-specific semantics. It is
2769 * only meaningful for amd64 targets.
2770 */
2774 /*
2775 * Target is x86, so this really is
2776 * SHT_AMD64_UNWIND
2777 */
2779 /*
2780 * column == ET_REL
2781 */
2787 FLG_IS_EHFRAME;
2788 }
2790 #endif
2792 do_default:
2796 S_ERROR)
2799 }
2800 }
2801 }
2803 /*
2804 * Now that all input sections have been analyzed, and prior to placing
2805 * any input sections to their output sections, process any groups.
2806 * Groups can contribute COMDAT items, which may get discarded as part
2807 * of placement. In addition, COMDAT names may require transformation
2808 * to indicate different output section placement.
2809 */
2820 }
2821 }
2823 /*
2824 * Now group information has been processed, we can safely validate
2825 * that nothing is fishy about the section COMDAT description. We
2826 * need to do this prior to placing the section (where any
2827 * SHT_SUNW_COMDAT sections will be restored to being PROGBITS)
2828 */
2831 /*
2832 * Now that all of the input sections have been processed, place
2833 * them in the appropriate output sections.
2834 */
2842 /*
2843 * Place all non-ordered sections within their appropriate
2844 * output section.
2845 */
2851 }
2853 /*
2854 * Count the number of ordered sections and retain the first
2855 * ordered section index. This will be used to optimize the
2856 * ordered section loop that immediately follows this one.
2857 */
2858 ordcnt++;
2861 }
2863 /*
2864 * Having placed all the non-ordered sections, it is now
2865 * safe to place SHF_ORDERED/SHF_LINK_ORDER sections.
2866 */
2877 /* ld_process_ordered() calls ld_place_section() */
2879 S_ERROR)
2882 /* If we've done them all, stop searching */
2885 }
2886 }
2888 /*
2889 * If this is a shared object explicitly specified on the command
2890 * line (as opposed to being a dependency of such an object),
2891 * determine if the user has specified a control definition. This
2892 * descriptor may specify which version definitions can be used
2893 * from this object. It may also update the dependency to USED and
2894 * supply an alternative SONAME.
2895 */
2900 /*
2901 * Use the basename of the input file (typically this is the
2902 * compilation environment name, ie. libfoo.so).
2903 */
2906 else
2907 base++;
2912 }
2913 }
2915 /*
2916 * Before symbol processing, process any capabilities. Capabilities
2917 * can reference a string table, which is why this processing is
2918 * carried out after the initial section processing. Capabilities,
2919 * together with -z symbolcap, can require the conversion of global
2920 * symbols to local symbols.
2921 */
2925 /*
2926 * Process any version dependencies. These will establish shared object
2927 * `needed' entries in the same manner as will be generated from the
2928 * .dynamic's NEEDED entries.
2929 */
2935 /*
2936 * Before processing any symbol resolution or relocations process any
2937 * version sections.
2938 */
2947 /*
2948 * Having collected the appropriate sections carry out any additional
2949 * processing if necessary.
2950 */
2962 /*
2963 * If this is a SHT_SUNW_move section from a relocatable file,
2964 * keep track of the section for later processing.
2965 */
2970 }
2972 /*
2973 * If this is a standard section type process it via the
2974 * appropriate action routine.
2975 */
2981 }
2982 #if defined(_ELF64)
2986 /*
2987 * SHT_AMD64_UNWIND (0x70000001) is in the SHT_LOPROC -
2988 * SHT_HIPROC range reserved for processor-specific
2989 * semantics, and is only meaningful for amd64 targets.
2990 *
2991 * Only process unwind contents from relocatable
2992 * objects.
2993 */
2997 #endif
2998 }
2999 }
3001 /*
3002 * Following symbol processing, if this relocatable object input file
3003 * provides symbol capabilities, tag the associated symbols so that
3004 * the symbols can be re-assigned to the new capabilities symbol
3005 * section that will be created for the output file.
3006 */
3011 /*
3012 * After processing any symbol resolution, and if this dependency
3013 * indicates it contains symbols that can't be directly bound to,
3014 * set the symbols appropriately.
3015 */
3021 }
3023 /*
3024 * Process the current input file. There are basically three types of files
3025 * that come through here:
3026 *
3027 * - files explicitly defined on the command line (ie. foo.o or bar.so),
3028 * in this case only the `name' field is valid.
3029 *
3030 * - libraries determined from the -l command line option (ie. -lbar),
3031 * in this case the `soname' field contains the basename of the located
3032 * file.
3033 *
3034 * Any shared object specified via the above two conventions must be recorded
3035 * as a needed dependency.
3036 *
3037 * - libraries specified as dependencies of those libraries already obtained
3038 * via the command line (ie. bar.so has a DT_NEEDED entry of fred.so.1),
3039 * in this case the `soname' field contains either a full pathname (if the
3040 * needed entry contained a `/'), or the basename of the located file.
3041 * These libraries are processed to verify symbol binding but are not
3042 * recorded as dependencies of the output file being generated.
3043 *
3044 * entry:
3045 * name - File name
3046 * soname - SONAME for needed sharable library, as described above
3047 * fd - Open file descriptor
3048 * elf - Open ELF handle
3049 * flags - FLG_IF_ flags applicable to file
3050 * ofl - Output file descriptor
3051 * rej - Rejection descriptor used to record rejection reason
3052 * ifl_ret - NULL, or address of pointer to receive reference to
3053 * resulting input descriptor for file. If ifl_ret is non-NULL,
3054 * the file cannot be an archive or it will be rejected.
3055 *
3056 * exit:
3057 * If a error occurs in examining the file, S_ERROR is returned.
3058 * If the file can be examined, but is not suitable, *rej is updated,
3059 * and 0 is returned. If the file is acceptable, 1 is returned, and if
3060 * ifl_ret is non-NULL, *ifl_ret is set to contain the pointer to the
3061 * resulting input descriptor.
3062 */
3063 uintptr_t
3066 {
3072 Rej_desc _rej;
3074 /*
3075 * If this file was not extracted from an archive obtain its device
3076 * information. This will be used to determine if the file has already
3077 * been processed (rather than simply comparing filenames, the device
3078 * information provides a quicker comparison and detects linked files).
3079 */
3085 }
3089 /*
3090 * If the caller has supplied a non-NULL ifl_ret, then
3091 * we cannot process archives, for there will be no
3092 * input file descriptor for us to return. In this case,
3093 * reject the attempt.
3094 */
3103 }
3105 }
3107 /*
3108 * Determine if we've already come across this archive file.
3109 */
3111 Aliste idx;
3118 /*
3119 * We've seen this file before so reuse the
3120 * original archive descriptor and discard the
3121 * new elf descriptor. Note that a file
3122 * descriptor is unnecessary, as the file is
3123 * already available in memory.
3124 */
3131 }
3132 }
3134 /*
3135 * As we haven't processed this file before establish a new
3136 * archive descriptor.
3137 */
3146 /*
3147 * Indicate that the ELF descriptor no longer requires a file
3148 * descriptor by reading the entire file. The file is already
3149 * read via the initial mmap(2) behind elf_begin(3elf), thus
3150 * this operation is effectively a no-op. However, a side-
3151 * effect is that the internal file descriptor, maintained in
3152 * the ELF descriptor, is set to -1. This setting will not
3153 * be compared with any file descriptor that is passed to
3154 * elf_begin(), should this archive, or one of the archive
3155 * members, be processed again from the command line or
3156 * because of a -z rescan.
3157 */
3160 name);
3162 }
3169 /*
3170 * Obtain the elf header so that we can determine what type of
3171 * elf ELF_K_ELF file this is.
3172 */
3176 /*
3177 * This can fail for a number of reasons. Typically
3178 * the object class is incorrect (ie. user is building
3179 * 64-bit but managed to point at 32-bit libraries).
3180 * Other ELF errors can include a truncated or corrupt
3181 * file. Try to get the best error message possible.
3182 */
3189 }
3196 }
3198 }
3200 /*
3201 * Determine if we've already come across this file.
3202 */
3205 Aliste idx;
3209 else
3212 /*
3213 * Traverse the appropriate file list and determine if
3214 * a dev/inode match is found.
3215 */
3217 /*
3218 * Ifl_desc generated via -Nneed, therefore no
3219 * actual file behind it.
3220 */
3228 /*
3229 * Disregard (skip) this image.
3230 */
3235 /*
3236 * If the file was explicitly defined on the
3237 * command line (this is always the case for
3238 * relocatable objects, and is true for shared
3239 * objects when they weren't specified via -l or
3240 * were dragged in as an implicit dependency),
3241 * then warn the user.
3242 */
3247 /*
3248 * Determine whether this is the same
3249 * file name as originally encountered
3250 * so as to provide the most
3251 * descriptive diagnostic.
3252 */
3253 errmsg =
3259 }
3263 }
3264 }
3266 /*
3267 * At this point, we know we need the file. Establish an input
3268 * file descriptor and continue processing.
3269 */
3276 /*
3277 * If -zignore is in effect, mark this file as a potential
3278 * candidate (the files use isn't actually determined until
3279 * symbol resolution and relocation processing are completed).
3280 */
3295 }
3297 /*
3298 * Record any additional shared object information.
3299 * If no soname is specified (eg. this file was
3300 * derived from a explicit filename declaration on the
3301 * command line, ie. bar.so) use the pathname.
3302 * This entry may be overridden if the files dynamic
3303 * section specifies an DT_SONAME value.
3304 */
3307 else
3310 /*
3311 * If direct bindings, lazy loading, group permissions,
3312 * or deferred dependencies need to be established, mark
3313 * this object.
3314 */
3327 /*
3328 * Determine whether this dependency requires a syminfo.
3329 */
3333 /*
3334 * Guidance: Use -z lazyload/nolazyload.
3335 * libc is exempt from this advice, because it cannot
3336 * be lazy loaded, and requests to do so are ignored.
3337 */
3343 }
3345 /*
3346 * Guidance: Use -B direct/nodirect or
3347 * -z direct/nodirect.
3348 */
3353 }
3365 }
3367 }
3378 }
3380 }
3387 }
3389 /*
3390 * Having successfully opened a file, set up the necessary elf structures to
3391 * process it further. This small section of processing is slightly different
3392 * from the elf initialization required to process a relocatable object from an
3393 * archive (see libs.c: ld_process_archive()).
3394 */
3395 uintptr_t
3398 {
3406 }
3408 /*
3409 * Determine whether the support library wishes to process this open.
3410 * The support library may return:
3411 * . a different ELF descriptor (in which case they should have
3412 * closed the original)
3413 * . a different file descriptor (in which case they should have
3414 * closed the original)
3415 * . a different path and file name (presumably associated with
3416 * a different file descriptor)
3417 *
3418 * A file descriptor of -1, or and ELF descriptor of zero indicates
3419 * the file should be ignored.
3420 */
3428 ifl_ret));
3429 }
3431 /*
3432 * Having successfully mapped a file, set up the necessary elf structures to
3433 * process it further. This routine is patterned after ld_process_open() and
3434 * is only called by ld.so.1(1) to process a relocatable object.
3435 */
3436 Ifl_desc *
3439 {
3447 }
3453 }
3455 /*
3456 * Process a required library (i.e. the dependency of a shared object).
3457 * Combine the directory and filename, check the resultant path size, and try
3458 * opening the pathname.
3459 */
3463 {
3469 /*
3470 * Determine the sizes of the directory and filename to insure we don't
3471 * exceed our buffer.
3472 */
3476 }
3477 dlen++;
3483 }
3485 /*
3486 * Build the entire pathname and try and open the file.
3487 */
3511 }
3512 }
3514 /*
3515 * Finish any library processing. Walk the list of so's that have been listed
3516 * as "included" by shared objects we have previously processed. Examine them,
3517 * without adding them as explicit dependents of this program, in order to
3518 * complete our symbol definition process. The search path rules are:
3519 *
3520 * - use any user supplied paths, i.e. LD_LIBRARY_PATH and -L, then
3521 *
3522 * - use any RPATH defined within the parent shared object, then
3523 *
3524 * - use the default directories, i.e. LIBPATH or -YP.
3525 */
3526 uintptr_t
3528 {
3529 Aliste idx1;
3533 /*
3534 * Make sure we are back in dynamic mode.
3535 */
3539 Aliste idx2;
3545 /*
3546 * See if this file has already been processed. At the time
3547 * this implicit dependency was determined there may still have
3548 * been more explicit dependencies to process. Note, if we ever
3549 * do parse the command line three times we would be able to
3550 * do all this checking when processing the dynamic section.
3551 */
3560 }
3561 }
3565 /*
3566 * If the current path name element embeds a "/", then it's to
3567 * be taken "as is", with no searching involved. Process all
3568 * "/" occurrences, so that we can deduce the base file name.
3569 */
3573 }
3593 Conv_reject_desc_buf_t rej_buf;
3603 }
3605 }
3607 /*
3608 * Now search for this file in any user defined directories.
3609 */
3616 }
3621 }
3622 }
3626 }
3627 }
3631 /*
3632 * Next use the local rules defined within the parent shared
3633 * object.
3634 */
3656 }
3662 }
3666 }
3669 }
3670 }
3674 /*
3675 * Finally try the default library search directories.
3676 */
3683 }
3688 }
3689 }
3693 }
3694 }
3698 /*
3699 * If we've got this far we haven't found the shared object.
3700 * If an object was found, but was rejected for some reason,
3701 * print a diagnostic to that effect, otherwise generate a
3702 * generic "not found" diagnostic.
3703 */
3705 Conv_reject_desc_buf_t rej_buf;
3716 }
3717 }
3719 /*
3720 * Finally, now that all objects have been input, make sure any version
3721 * requirements have been met.
3722 */
3724 }