| blob | 6c1139f5287c7cc7eaf0cd5c9cdd2e419aed7fa4 |
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 */
315 }
316 #endif
318 }
325 }
327 /*
328 * Determine the resolution of the present frame pointer and the
329 * new input relocatable objects frame pointer.
330 */
332 /*
333 * If the new relocatable object isn't using a frame pointer,
334 * reduce the present state to unused.
335 */
339 /*
340 * Having processed the frame pointer bits, remove them from
341 * the value so they don't get OR'd in below.
342 */
346 /*
347 * If the present frame pointer state is unknown, mask it out
348 * and allow the values from the new relocatable object
349 * to overwrite them.
350 */
353 /* Do not take the frame pointer flags from the object */
355 }
362 #undef FP_FLAGS
363 }
365 /*
366 * Determine the hardware capabilities of the object being built from the
367 * capabilities of the input relocatable objects. There's really little to
368 * do here, other than to offer diagnostics, hardware capabilities are simply
369 * additive.
370 */
371 static void
373 {
375 ofl_flag_t flags1;
383 }
385 /*
386 * If a mapfile has established definitions to override any object
387 * capabilities, ignore any new object capabilities.
388 */
393 }
395 /*
396 * If this object doesn't specify any capabilities, ignore it, and
397 * leave the state as is.
398 */
407 }
413 }
415 /*
416 * Promote a machine capability or platform capability to the output file.
417 * Multiple instances of these names can be defined.
418 */
419 static void
421 {
423 Aliste idx;
426 /*
427 * If a mapfile has established definitions to override this capability,
428 * ignore any new capability.
429 */
434 }
441 }
450 }
452 }
458 }
459 }
460 }
462 /*
463 * Promote a capability identifier to the output file. A capability group can
464 * only have one identifier, and thus only the first identifier seen from any
465 * input relocatable objects is retained. An explicit user defined identifier,
466 * rather than an an identifier fabricated by ld(1) with -z symbcap processing,
467 * takes precedence. Note, a user may have defined an identifier via a mapfile,
468 * in which case the mapfile identifier is retained.
469 */
470 static void
472 {
484 }
485 }
495 }
497 /*
498 * Promote a capabilities group to the object capabilities. This catches a
499 * corner case. An object capabilities file can be converted to symbol
500 * capabilities with -z symbolcap. However, if the user has indicated that all
501 * the symbols should be demoted, we'd be left with a symbol capabilities file,
502 * with no associated symbols. Catch this case by promoting the symbol
503 * capabilities back to object capabilities.
504 */
505 void
507 {
509 Aliste idx1;
514 Aliste idx2;
520 }
523 capstr)) {
526 }
527 }
530 capstr)) {
533 }
534 }
543 }
544 }
546 /*
547 * Determine whether a capabilities group already exists that describes this
548 * new capabilities group.
549 *
550 * Note, a capability group identifier, CA_SUNW_ID, isn't used as part of the
551 * comparison. This attribute simply assigns a diagnostic name to the group,
552 * and in the case of multiple identifiers, the first will be taken.
553 */
556 {
557 Aliste idx;
561 /*
562 * If the new capabilities contains a CA_SUNW_ID, drop the count of the
563 * number of comparable items.
564 */
566 ccnum--;
568 /*
569 * Traverse the existing symbols capabilities groups.
570 */
576 onum--;
602 /*
603 * If a matching group is found, then this new group has
604 * already been supplied by a previous file, and hence the
605 * existing group can be used. Record this new input section,
606 * from which we can also derive the input file name, on the
607 * existing groups input sections.
608 */
613 }
615 /*
616 * If a capabilities group is not found, create a new one.
617 */
623 /*
624 * If we're converting object capabilities to symbol capabilities and
625 * no CA_SUNW_ID is defined, fabricate one. This identifier is appended
626 * to all symbol names that are converted into capabilities symbols,
627 * see ld_sym_process().
628 */
633 /*
634 * Create an identifier using the group number together with a
635 * default template. We allocate a buffer large enough for any
636 * possible number of items (way more than we need).
637 */
645 cnum++;
646 }
651 /*
652 * Null the callers alist's as they've effectively been transferred
653 * to this new Cap_group.
654 */
657 /*
658 * Keep track of which input section, and hence input file, established
659 * this group.
660 */
664 /*
665 * Keep track of the number of symbol capabilities entries that will be
666 * required in the output file. Each group requires a terminating
667 * CA_SUNW_NULL.
668 */
671 }
673 /*
674 * Capture symbol capability family information. This data structure is focal
675 * in maintaining all symbol capability relationships, and provides for the
676 * eventual creation of a capabilities information section, and possibly a
677 * capabilities chain section.
678 *
679 * Capabilities families are lead by a CAPINFO_SUNW_GLOB symbol. This symbol
680 * provides the visible global symbol that is referenced by all external
681 * callers. This symbol may have aliases. For example, a weak/global symbol
682 * pair, such as memcpy()/_memcpy() may lead the same capabilities family.
683 * Each family contains one or more local symbol members. These members provide
684 * the capabilities specific functions, and are associated to a capabilities
685 * group. For example, the capability members memcpy%sun4u and memcpy%sun4v
686 * might be associated with the memcpy() capability family.
687 *
688 * This routine is called when a relocatable object that provides object
689 * capabilities is transformed into a symbol capabilities object, using the
690 * -z symbolcap option.
691 *
692 * This routine is also called to collect the SUNW_capinfo section information
693 * of a relocatable object that contains symbol capability definitions.
694 */
695 uintptr_t
698 {
703 Aliste idx;
705 /*
706 * Make sure the capability families have an initialized AVL tree.
707 */
715 /*
716 * When creating a dynamic object, capability family members
717 * are maintained in a .SUNW_capchain, the first entry of
718 * which is the version number of the chain.
719 */
721 }
723 /*
724 * Determine whether a family already exists, and if not, create one
725 * using the lead family symbol.
726 */
739 /*
740 * When creating a dynamic object, capability family members
741 * are maintained in a .SUNW_capchain, each family starts with
742 * this lead symbol, and is terminated with a 0 element.
743 */
745 }
747 /*
748 * If no group information is provided then this request is to add a
749 * lead capability symbol, or lead symbol alias. If this is the lead
750 * symbol there's nothing more to do. Otherwise save the alias.
751 */
758 }
760 /*
761 * Determine whether a member of the same group as this new member is
762 * already defined within this family. If so, we have a multiply
763 * defined symbol.
764 */
771 /*
772 * Diagnose that a multiple symbol definition exists.
773 */
781 }
783 /*
784 * Add this capabilities symbol member to the family.
785 */
793 /*
794 * When creating a dynamic object, capability family members are
795 * maintained in a .SUNW_capchain. Account for this family member.
796 */
799 /*
800 * If this input file is undergoing object capabilities to symbol
801 * capabilities conversion, then this member is a new local symbol
802 * that has been generated from an original global symbol. Keep track
803 * of this symbol so that the output file symbol table can be populated
804 * with these new symbol entries.
805 */
810 }
812 /*
813 * Process a SHT_SUNW_cap capabilities section.
814 */
815 static uintptr_t
817 {
826 /*
827 * Determine the capabilities data and size.
828 */
837 /*
838 * Traverse the section to determine what capabilities groups are
839 * available.
840 *
841 * A capabilities section can contain one or more, CA_SUNW_NULL
842 * terminated groups.
843 *
844 * - The first group defines the object capabilities.
845 * - Additional groups define symbol capabilities.
846 * - Since the initial group is always reserved for object
847 * capabilities, any object with symbol capabilities must also
848 * have an object capabilities group. If the object has no object
849 * capabilities, an empty object group is defined, consisting of a
850 * CA_SUNW_NULL element in index [0].
851 * - If any capabilities require references to a named string, then
852 * the section header sh_info points to the associated string
853 * table.
854 * - If an object contains symbol capability groups, then the
855 * section header sh_link points to the associated capinfo table.
856 */
864 /*
865 * If this is the first CA_SUNW_NULL entry, and no
866 * capabilities group has been found, then this object
867 * does not define any object capabilities.
868 */
880 capstrs++;
881 /* FALLTHROUGH */
886 /*
887 * If this is the start of a new group, save it.
888 */
897 }
898 }
900 /*
901 * If a string capabilities entry has been found, the capabilities
902 * section must reference the associated string table.
903 */
912 }
914 }
916 /*
917 * The processing of capabilities groups is as follows:
918 *
919 * - if a relocatable object provides only object capabilities, and
920 * the -z symbolcap option is in effect, then the object
921 * capabilities are transformed into symbol capabilities and the
922 * symbol capabilities are carried over to the output file.
923 * - in all other cases, any capabilities present in an input
924 * relocatable object are carried from the input object to the
925 * output without any transformation or conversion.
926 *
927 * Capture any object capabilities that are to be carried over to the
928 * output file.
929 */
933 /*
934 * Object capabilities end at the first null.
935 */
939 /*
940 * Only the object software capabilities that are
941 * defined in a relocatable object become part of the
942 * object software capabilities in the output file.
943 * However, check the validity of any object software
944 * capabilities of any dependencies.
945 */
949 }
951 /*
952 * The remaining capability types must come from a
953 * relocatable object in order to contribute to the
954 * output.
955 */
979 FLG_OCS_USRDEFID);
984 }
985 }
987 /*
988 * If there are no symbol capabilities, or this objects
989 * capabilities aren't being transformed into a symbol
990 * capabilities, then we're done.
991 */
995 }
997 /*
998 * If these capabilities don't originate from a relocatable object
999 * there's no further processing required.
1000 */
1004 /*
1005 * If this object only defines an object capabilities group, and the
1006 * -z symbolcap option is in effect, then all global function symbols
1007 * and initialized global data symbols are renamed and assigned to the
1008 * transformed symbol capabilities group.
1009 */
1014 /*
1015 * Allocate a capabilities descriptor to collect the capabilities data
1016 * for this input file. Allocate a mirror of the raw capabilities data
1017 * that points to the individual symbol capabilities groups. An APlist
1018 * is used, although it will be sparsely populated, as the list provides
1019 * a convenient mechanism for traversal later.
1020 */
1025 /*
1026 * Clear the allocated APlist data array, and assign the number of
1027 * items as the total number of array items.
1028 */
1035 /*
1036 * Traverse the capabilities data, unpacking the data into a
1037 * capabilities set. Process each capabilities set as a unique group.
1038 */
1047 nulls++;
1049 /*
1050 * Process the capabilities group that this null entry
1051 * terminates. The capabilities group that is returned
1052 * will either point to this file's data, or to a
1053 * matching capabilities group that has already been
1054 * processed.
1055 *
1056 * Note, if this object defines object capabilities,
1057 * the first group descriptor points to these object
1058 * capabilities. It is only necessary to save this
1059 * descriptor when object capabilities are being
1060 * transformed into symbol capabilities (-z symbolcap).
1061 */
1072 }
1074 /*
1075 * Clean up the capabilities data in preparation
1076 * for processing additional groups. If the
1077 * collected capabilities strings were used to
1078 * establish a new output group, they will have
1079 * been saved in get_cap_group(). If these
1080 * descriptors still exist, then an existing
1081 * descriptor has been used to associate with
1082 * this file, and these string descriptors can
1083 * be freed.
1084 */
1091 }
1095 }
1097 }
1145 }
1147 /*
1148 * Save the start of this new group.
1149 */
1152 }
1154 }
1156 /*
1157 * Capture any symbol capabilities symbols. An object file that contains symbol
1158 * capabilities has an associated .SUNW_capinfo section. This section
1159 * identifies which symbols are associated to which capabilities, together with
1160 * their associated lead symbol. Each of these symbol pairs are recorded for
1161 * processing later.
1162 */
1163 static uintptr_t
1165 {
1178 Word lndx;
1179 uchar_t gndx;
1185 /*
1186 * Catch any anomalies. A capabilities symbol should be valid,
1187 * and the capabilities lead symbol should also be global.
1188 * Note, ld(1) -z symbolcap would create local capabilities
1189 * symbols, but we don't enforce this so as to give the
1190 * compilation environment a little more freedom.
1191 */
1198 }
1206 lndx);
1208 }
1210 /*
1211 * Indicate that this is a capabilities symbol.
1212 */
1215 /*
1216 * Save any global capability symbols. Global capability
1217 * symbols are identified with a CAPINFO_SUNW_GLOB group id.
1218 * The lead symbol for this global capability symbol is either
1219 * the symbol itself, or an alias.
1220 */
1226 }
1228 /*
1229 * Track the number of non-global capabilities symbols, as these
1230 * are used to size any symbol tables. If we're generating a
1231 * dynamic object, this symbol will be added to the dynamic
1232 * symbol table, therefore ensure there is space in the dynamic
1233 * string table.
1234 */
1240 /*
1241 * As we're tracking this local symbol as a capabilities symbol,
1242 * reduce the local symbol count to compensate.
1243 */
1246 /*
1247 * Determine whether the associated lead symbol indicates
1248 * NODYNSORT. If so, remove this local entry from the
1249 * SUNW_dynsort section too. NODYNSORT tagging can only be
1250 * obtained from a mapfile symbol definition, and thus any
1251 * global definition that has this tagging has already been
1252 * instantiated and this instance resolved to it.
1253 */
1260 }
1262 /*
1263 * Track this family member, together with its associated group.
1264 */
1268 }
1271 }
1273 /*
1274 * Simply process the section so that we have pointers to the data for use
1275 * in later routines, however don't add the section to the output section
1276 * list as we will be creating our own replacement sections later (ie.
1277 * symtab and relocation).
1278 */
1279 static uintptr_t
1280 /* ARGSUSED5 */
1283 {
1286 }
1288 /*
1289 * Keep a running count of relocation entries from input relocatable objects for
1290 * sizing relocation buckets later. If we're building an executable, save any
1291 * relocations from shared objects to determine if any copy relocation symbol
1292 * has a displacement relocation against it.
1293 */
1294 static uintptr_t
1295 /* ARGSUSED5 */
1298 {
1305 /* LINTED */
1312 }
1314 }
1316 /*
1317 * Process a string table section. A valid section contains an initial and
1318 * final null byte.
1319 */
1320 static uintptr_t
1323 {
1329 /*
1330 * Never include .stab.excl sections in any output file.
1331 * If the -s flag has been specified strip any .stab sections.
1332 */
1338 /*
1339 * If we got here to process a .shstrtab or .dynstr table, `ident' will
1340 * be null. Otherwise make sure we don't have a .strtab section as this
1341 * should not be added to the output section list either.
1342 */
1351 /*
1352 * String tables should start and end with a NULL byte. Note, it has
1353 * been known for the assembler to create empty string tables, so check
1354 * the size before attempting to verify the data itself.
1355 */
1369 }
1371 /*
1372 * Invalid sections produce a warning and are skipped.
1373 */
1374 static uintptr_t
1375 /* ARGSUSED3 */
1378 {
1379 Conv_inv_buf_t inv_buf;
1386 }
1388 /*
1389 * Compare an input section name to a given string, taking the ELF '%'
1390 * section naming convention into account. If an input section name
1391 * contains a '%' character, the '%' and all following characters are
1392 * ignored in the comparison.
1393 *
1394 * entry:
1395 * is_name - Name of input section
1396 * match_name - Name to compare to
1397 * match_len - strlen(match_name)
1398 *
1399 * exit:
1400 * Returns True (1) if the names match, and False (0) otherwise.
1401 */
1404 {
1405 /*
1406 * If the start of is_name is not a match for name,
1407 * the match fails.
1408 */
1412 /*
1413 * The prefix matched. The next character must be either '%', or
1414 * NULL, in order for a match to be true.
1415 */
1418 }
1420 /*
1421 * Helper routine for process_progbits() to process allocable sections.
1422 *
1423 * entry:
1424 * name, ifl, shdr, ndx, ident, ofl - As passed to process_progbits().
1425 * is_stab_index - TRUE if section is .index.
1426 * is_flags - Additional flags to be added to the input section.
1427 *
1428 * exit:
1429 * The allocable section has been processed. *ident and *is_flags
1430 * are updated as necessary to reflect the changes. Returns TRUE
1431 * for success, FALSE for failure.
1432 */
1433 /*ARGSUSED*/
1438 {
1445 MSG_SCN_EHFRAME_SIZE))
1452 /*
1453 * Historically, the section containing the logic to
1454 * unwind stack frames -- the .eh_frame section -- was
1455 * of type SHT_PROGBITS. Apparently the most
1456 * aesthetically galling aspect of this was not the
1457 * .eh_frame section's dubious purpose or its filthy
1458 * implementation, but rather its section type; with the
1459 * introduction of the AMD64 ABI, a new section header
1460 * type (SHT_AMD64_UNWIND) was introduced for (and
1461 * dedicated to) this section. When both the Sun
1462 * compilers and the GNU compilers had been modified to
1463 * generate this new section type, the linker became
1464 * much more pedantic about .eh_frame: it refused to
1465 * link an AMD64 object that contained a .eh_frame with
1466 * the legacy SHT_PROGBITS. That this was too fussy is
1467 * evidenced by searching the net for the error message
1468 * that it generated ("section type is SHT_PROGBITS:
1469 * expected SHT_AMD64_UNWIND"), which reveals a myriad
1470 * of problems, including legacy objects, hand-coded
1471 * assembly and otherwise cross-platform objects
1472 * created on other platforms (the GNU toolchain was
1473 * only modified to create the new section type on
1474 * Solaris and derivatives). We therefore always accept
1475 * a .eh_frame of SHT_PROGBITS -- regardless of
1476 * m_sht_unwind.
1477 */
1481 MSG_SCN_GOT_SIZE)) {
1485 }
1488 MSG_SCN_GCC_X_TBL_SIZE)) {
1492 }
1496 MSG_SCN_PLT_SIZE)) {
1499 }
1501 }
1502 }
1505 /*
1506 * This is a work-around for x86 compilers that have
1507 * set SHF_ALLOC for the .stab.index section.
1508 *
1509 * Because of this, make sure that the .stab.index
1510 * does not end up as the last section in the text
1511 * segment. Older linkers can produce segmentation
1512 * violations when they strip (ld -s) against a
1513 * shared object whose last section in the text
1514 * segment is a .stab.
1515 */
1519 }
1520 }
1523 }
1525 /*
1526 * Process a progbits section.
1527 */
1528 static uintptr_t
1531 {
1536 /*
1537 * Never include .stab.excl sections in any output file.
1538 * If the -s flag has been specified strip any .stab sections.
1539 */
1550 }
1557 }
1559 /*
1560 * Update the ident to reflect the type of section we've got.
1561 *
1562 * If there is any .plt or .got section to generate we'll be creating
1563 * our own version, so don't allow any input sections of these types to
1564 * be added to the output section list (why a relocatable object would
1565 * have a .plt or .got is a mystery, but stranger things have occurred).
1566 *
1567 * If there are any unwind sections, and this is a platform that uses
1568 * SHT_PROGBITS for unwind sections, then set their ident to reflect
1569 * that.
1570 */
1583 }
1584 }
1588 /*
1589 * On success, process_section() creates an input section descriptor.
1590 * Now that it exists, we can add any pending input section flags.
1591 */
1596 }
1598 /*
1599 * Handles the SHT_SUNW_{DEBUG,DEBUGSTR) sections.
1600 */
1601 static uintptr_t
1604 {
1605 /*
1606 * Debug information is discarded when the 'ld -s' flag is invoked.
1607 */
1610 }
1612 }
1614 /*
1615 * Process a nobits section.
1616 */
1617 static uintptr_t
1620 {
1624 #if defined(_ELF64)
1628 #endif
1629 else
1631 }
1633 }
1635 /*
1636 * Process a SHT_*_ARRAY section.
1637 */
1638 static uintptr_t
1641 {
1652 }
1654 static uintptr_t
1655 /* ARGSUSED1 */
1657 {
1677 }
1679 /*
1680 * Process a SHT_SYMTAB_SHNDX section.
1681 */
1682 static uintptr_t
1685 {
1689 /*
1690 * Have we already seen the related SYMTAB - if so verify it now.
1691 */
1701 }
1703 }
1705 }
1707 /*
1708 * Final processing for SHT_SYMTAB_SHNDX section.
1709 */
1710 static uintptr_t
1711 /* ARGSUSED2 */
1713 {
1724 }
1726 }
1728 }
1730 /*
1731 * Process .dynamic section from a relocatable object.
1732 *
1733 * Note: That the .dynamic section is only considered interesting when
1734 * dlopen()ing a relocatable object (thus FLG_OF1_RELDYN can only get
1735 * set when libld is called from ld.so.1).
1736 */
1737 /*ARGSUSED*/
1738 static uintptr_t
1741 {
1747 /*
1748 * Process .dynamic sections from relocatable objects ?
1749 */
1753 /*
1754 * Find the string section associated with the .dynamic section.
1755 */
1760 }
1764 /*
1765 * And get the .dynamic data
1766 */
1793 /*
1794 * The Solaris ld does not put DT_VERSYM in the
1795 * dynamic section. If the object has DT_VERSYM,
1796 * then it must have been produced by the GNU ld,
1797 * and is using the GNU style of versioning.
1798 */
1801 }
1802 }
1804 }
1806 /*
1807 * Expand implicit references. Dependencies can be specified in terms of the
1808 * $ORIGIN, $MACHINE, $PLATFORM, $OSREL and $OSNAME tokens, either from their
1809 * needed name, or via a runpath. In addition runpaths may also specify the
1810 * $ISALIST token.
1811 *
1812 * Probably the most common reference to explicit dependencies (via -L) will be
1813 * sufficient to find any associated implicit dependencies, but just in case we
1814 * expand any occurrence of these known tokens here.
1815 *
1816 * Note, if any errors occur we simply return the original name.
1817 *
1818 * This code is remarkably similar to expand() in rtld/common/paths.c.
1819 */
1829 {
1845 }
1853 /*
1854 * For $ORIGIN, expansion is really just a concatenation
1855 * of the parents directory name. For example, an
1856 * explicit dependency foo/bar/lib1.so with a dependency
1857 * on $ORIGIN/lib2.so would be expanded to
1858 * foo/bar/lib2.so.
1859 */
1862 nrem--;
1872 }
1878 /*
1879 * Establish the machine from sysconf - like uname -i.
1880 */
1892 }
1903 }
1907 /*
1908 * Establish the platform from sysconf - like uname -i.
1909 */
1921 }
1932 }
1936 /*
1937 * Establish the os name - like uname -s.
1938 */
1953 }
1957 /*
1958 * Establish the os release - like uname -r.
1959 */
1974 }
1978 /*
1979 * Establish instruction sets from sysconf. Note that
1980 * this is only meaningful from runpaths.
1981 */
2002 /*
2003 * As ISALIST expands to a number of elements,
2004 * establish a new list to return to the caller.
2005 * This will contain the present path being
2006 * processed redefined for each isalist option,
2007 * plus the original remaining list entries.
2008 */
2026 }
2029 else
2031 }
2032 }
2034 /*
2035 * If no expansion occurred skip the $ and continue.
2036 */
2039 }
2041 /*
2042 * If any ISALIST processing has occurred not only do we return the
2043 * expanded node we're presently working on, but we must also update the
2044 * remaining list so that it is effectively prepended with this node
2045 * expanded to all remaining isalist options. Note that we can only
2046 * handle one ISALIST per node. For more than one ISALIST to be
2047 * processed we'd need a better algorithm than above to replace the
2048 * newly generated list. Whether we want to encourage the number of
2049 * pathname permutations this would provide is another question. So, for
2050 * now if more than one ISALIST is encountered we return the original
2051 * node untouched.
2052 */
2056 else
2058 }
2067 }
2069 }
2071 /*
2072 * The Solaris ld does not put DT_VERSYM in the dynamic section, but the
2073 * GNU ld does, and it is used by the runtime linker to implement their
2074 * versioning scheme. Use this fact to determine if the sharable object
2075 * was produced by the GNU ld rather than the Solaris one, and to set
2076 * FLG_IF_GNUVER if so. This needs to be done before the symbols are
2077 * processed, since the answer determines whether we interpret the
2078 * symbols versions according to Solaris or GNU rules.
2079 */
2080 /*ARGSUSED*/
2081 static uintptr_t
2084 {
2093 /* Get the .dynamic data */
2100 }
2101 }
2103 }
2105 /*
2106 * Process a dynamic section. If we are processing an explicit shared object
2107 * then we need to determine if it has a recorded SONAME, if so, this name will
2108 * be recorded in the output file being generated as the NEEDED entry rather
2109 * than the shared objects filename itself.
2110 * If the mode of the link-edit indicates that no undefined symbols should
2111 * remain, then we also need to build up a list of any additional shared object
2112 * dependencies this object may have. In this case save any NEEDED entries
2113 * together with any associated run-path specifications. This information is
2114 * recorded on the `ofl_soneed' list and will be analyzed after all explicit
2115 * file processing has been completed (refer finish_libs()).
2116 */
2117 static uintptr_t
2119 {
2123 Boolean no_undef;
2128 /* Determine if we need to examine the runpaths and NEEDED entries */
2132 /*
2133 * First loop through the dynamic section looking for a run path.
2134 */
2143 }
2144 }
2146 /*
2147 * Now look for any needed dependencies (which may use the rpath)
2148 * or a new SONAME.
2149 */
2155 /*
2156 * Update the input file structure with this new name.
2157 */
2169 /*
2170 * Determine if this needed entry is already recorded on
2171 * the shared object needed list, if not create a new
2172 * definition for later processing (see finish_libs()).
2173 */
2181 }
2183 /*
2184 * Record the runpath (Note that we take the first
2185 * runpath which is exactly what ld.so.1 would do during
2186 * its dependency processing).
2187 */
2201 /*
2202 * If we are building an executable, and this
2203 * dependency is tagged as an interposer, then
2204 * assume that it is required even if symbol
2205 * resolution uncovers no evident use.
2206 *
2207 * If we are building a shared object, then an
2208 * interposer dependency has no special meaning, and we
2209 * treat it as a regular dependency. By definition, all
2210 * interposers must be visible to the runtime linker
2211 * at initialization time, and cannot be added later.
2212 */
2219 /*
2220 * Record audit string as DT_DEPAUDIT.
2221 */
2228 /*
2229 * If this dependency has the DT_SUNW_RTLDINF .dynamic
2230 * entry, then ensure no specialized dependency
2231 * processing is in effect. This tag identifies libc,
2232 * which provides critical startup information (TLS
2233 * routines, threads initialization, etc.) that must
2234 * be exercised as part of process initialization.
2235 */
2238 /*
2239 * libc is not subject to the usual guidance checks
2240 * for lazy loading. It cannot be lazy loaded, libld
2241 * ignores the request, and rtld would ignore the
2242 * setting if it were present.
2243 */
2245 }
2246 }
2248 /*
2249 * Perform some SONAME sanity checks.
2250 */
2253 Aliste idx;
2255 /*
2256 * Determine if anyone else will cause the same SONAME to be
2257 * used (this is either caused by two different files having the
2258 * same SONAME, or by one file SONAME actually matching another
2259 * file basename (if no SONAME is specified within a shared
2260 * library its basename will be used)). Probably rare, but some
2261 * idiot will do it.
2262 */
2268 /*
2269 * Determine the basename of each file. Perhaps
2270 * there are multiple copies of the same file
2271 * being brought in using different -L search
2272 * paths, and if so give an extra hint in the
2273 * error message.
2274 */
2278 else
2279 iflb++;
2284 else
2285 siflb++;
2289 else
2296 }
2297 }
2299 /*
2300 * If the SONAME is the same as the name the user wishes to
2301 * record when building a dynamic library (refer -h option),
2302 * we also have a name clash.
2303 */
2310 }
2311 }
2313 }
2315 /*
2316 * Process a progbits section from a relocatable object (ET_REL).
2317 * This is used on non-amd64 objects to recognize .eh_frame sections.
2318 */
2319 /*ARGSUSED1*/
2320 static uintptr_t
2322 {
2328 }
2330 /*
2331 * Process a group section.
2332 */
2333 static uintptr_t
2336 {
2343 /*
2344 * Indicate that this input file has groups to process. Groups are
2345 * processed after all input sections have been processed.
2346 */
2350 }
2352 /*
2353 * Process a relocation entry. At this point all input sections from this
2354 * input file have been assigned an input section descriptor which is saved
2355 * in the `ifl_isdesc' array.
2356 */
2357 static uintptr_t
2359 {
2360 Word rndx;
2364 Conv_inv_buf_t inv_buf;
2366 /*
2367 * Make sure this is a valid relocation we can handle.
2368 */
2375 }
2377 /*
2378 * From the relocation section header information determine which
2379 * section needs the actual relocation. Determine which output section
2380 * this input section has been assigned to and add to its relocation
2381 * list. Note that the relocation section may be null if it is not
2382 * required (ie. .debug, .stabs, etc).
2383 */
2386 /*
2387 * Broken input file.
2388 */
2393 }
2400 /*
2401 * Discard relocations if they are against a section
2402 * which has been discarded.
2403 */
2409 /*
2410 * This section is processed later in
2411 * process_movereloc().
2412 */
2417 }
2423 }
2427 }
2429 }
2431 /*
2432 * SHF_EXCLUDE flags is set for this section.
2433 */
2434 static uintptr_t
2437 {
2438 /*
2439 * Sections SHT_SYMTAB and SHT_DYNDYM, even if SHF_EXCLUDE is on, might
2440 * be needed for ld processing. These sections need to be in the
2441 * internal table. Later it will be determined whether they can be
2442 * eliminated or not.
2443 */
2447 /*
2448 * Other checks
2449 */
2451 /*
2452 * A conflict, issue an warning message, and ignore the section.
2453 */
2457 }
2459 /*
2460 * This sections is not going to the output file.
2461 */
2463 }
2465 /*
2466 * Section processing state table. `Initial' describes the required initial
2467 * procedure to be called (if any), `Final' describes the final processing
2468 * procedure (ie. things that can only be done when all required sections
2469 * have been collected).
2470 */
2475 /* ET_REL ET_DYN */
2496 };
2501 /* ET_REL ET_DYN */
2522 };
2524 #define MAXNDXSIZE 10
2526 /*
2527 * Process an elf file. Each section is compared against the section state
2528 * table to determine whether it should be processed (saved), ignored, or
2529 * is invalid for the type of input file being processed.
2530 */
2531 static uintptr_t
2533 {
2546 /*
2547 * Path information buffer used by ld_place_section() and related
2548 * routines. This information is used to evaluate entrance criteria
2549 * with non-empty file matching lists (ec_files).
2550 */
2553 /*
2554 * First process the .shstrtab section so that later sections can
2555 * reference their name.
2556 */
2564 }
2569 }
2571 NULL) {
2575 }
2581 /*
2582 * Reset the name since the shdr->sh_name could have been changed as
2583 * part of ld_sup_input_section().
2584 */
2586 NULL) {
2590 }
2597 /*
2598 * Determine the state table column from the input file type. Note,
2599 * shared library sections are not added to the output section list.
2600 */
2609 }
2616 ndx++;
2618 /*
2619 * As we've already processed the .shstrtab don't do it again.
2620 */
2628 }
2635 /*
2636 * Reset the name since the shdr->sh_name could have been
2637 * changed as part of ld_sup_input_section().
2638 */
2643 /*
2644 * If the section has the SHF_EXCLUDE flag on, and we're not
2645 * generating a relocatable object, exclude the section.
2646 */
2654 }
2656 /*
2657 * If this is a standard section type process it via the
2658 * appropriate action routine.
2659 */
2665 }
2667 /*
2668 * If this section is below SHT_LOSUNW then we don't
2669 * really know what to do with it, issue a warning
2670 * message but do the basic section processing anyway.
2671 */
2673 Conv_inv_buf_t inv_buf;
2681 }
2683 /*
2684 * Handle sections greater than SHT_LOSUNW.
2685 */
2751 /*
2752 * SHT_SPARC_GOTDATA (0x70000000) is in the
2753 * SHT_LOPROC - SHT_HIPROC range reserved
2754 * for processor-specific semantics. It is
2755 * only meaningful for sparc targets.
2756 */
2764 #if defined(_ELF64)
2766 /*
2767 * SHT_AMD64_UNWIND (0x70000001) is in the
2768 * SHT_LOPROC - SHT_HIPROC range reserved
2769 * for processor-specific semantics. It is
2770 * only meaningful for amd64 targets.
2771 */
2775 /*
2776 * Target is x86, so this really is
2777 * SHT_AMD64_UNWIND
2778 */
2780 /*
2781 * column == ET_REL
2782 */
2788 FLG_IS_EHFRAME;
2789 }
2791 #endif
2793 do_default:
2797 S_ERROR)
2800 }
2801 }
2802 }
2804 /*
2805 * Now that all input sections have been analyzed, and prior to placing
2806 * any input sections to their output sections, process any groups.
2807 * Groups can contribute COMDAT items, which may get discarded as part
2808 * of placement. In addition, COMDAT names may require transformation
2809 * to indicate different output section placement.
2810 */
2821 }
2822 }
2824 /*
2825 * Now group information has been processed, we can safely validate
2826 * that nothing is fishy about the section COMDAT description. We
2827 * need to do this prior to placing the section (where any
2828 * SHT_SUNW_COMDAT sections will be restored to being PROGBITS)
2829 */
2832 /*
2833 * Now that all of the input sections have been processed, place
2834 * them in the appropriate output sections.
2835 */
2843 /*
2844 * Place all non-ordered sections within their appropriate
2845 * output section.
2846 */
2852 }
2854 /*
2855 * Count the number of ordered sections and retain the first
2856 * ordered section index. This will be used to optimize the
2857 * ordered section loop that immediately follows this one.
2858 */
2859 ordcnt++;
2862 }
2864 /*
2865 * Having placed all the non-ordered sections, it is now
2866 * safe to place SHF_ORDERED/SHF_LINK_ORDER sections.
2867 */
2878 /* ld_process_ordered() calls ld_place_section() */
2880 S_ERROR)
2883 /* If we've done them all, stop searching */
2886 }
2887 }
2889 /*
2890 * If this is a shared object explicitly specified on the command
2891 * line (as opposed to being a dependency of such an object),
2892 * determine if the user has specified a control definition. This
2893 * descriptor may specify which version definitions can be used
2894 * from this object. It may also update the dependency to USED and
2895 * supply an alternative SONAME.
2896 */
2901 /*
2902 * Use the basename of the input file (typically this is the
2903 * compilation environment name, ie. libfoo.so).
2904 */
2907 else
2908 base++;
2913 }
2914 }
2916 /*
2917 * Before symbol processing, process any capabilities. Capabilities
2918 * can reference a string table, which is why this processing is
2919 * carried out after the initial section processing. Capabilities,
2920 * together with -z symbolcap, can require the conversion of global
2921 * symbols to local symbols.
2922 */
2926 /*
2927 * Process any version dependencies. These will establish shared object
2928 * `needed' entries in the same manner as will be generated from the
2929 * .dynamic's NEEDED entries.
2930 */
2936 /*
2937 * Before processing any symbol resolution or relocations process any
2938 * version sections.
2939 */
2948 /*
2949 * Having collected the appropriate sections carry out any additional
2950 * processing if necessary.
2951 */
2963 /*
2964 * If this is a SHT_SUNW_move section from a relocatable file,
2965 * keep track of the section for later processing.
2966 */
2971 }
2973 /*
2974 * If this is a standard section type process it via the
2975 * appropriate action routine.
2976 */
2982 }
2983 #if defined(_ELF64)
2987 /*
2988 * SHT_AMD64_UNWIND (0x70000001) is in the SHT_LOPROC -
2989 * SHT_HIPROC range reserved for processor-specific
2990 * semantics, and is only meaningful for amd64 targets.
2991 *
2992 * Only process unwind contents from relocatable
2993 * objects.
2994 */
2998 #endif
2999 }
3000 }
3002 /*
3003 * Following symbol processing, if this relocatable object input file
3004 * provides symbol capabilities, tag the associated symbols so that
3005 * the symbols can be re-assigned to the new capabilities symbol
3006 * section that will be created for the output file.
3007 */
3012 /*
3013 * After processing any symbol resolution, and if this dependency
3014 * indicates it contains symbols that can't be directly bound to,
3015 * set the symbols appropriately.
3016 */
3022 }
3024 /*
3025 * Process the current input file. There are basically three types of files
3026 * that come through here:
3027 *
3028 * - files explicitly defined on the command line (ie. foo.o or bar.so),
3029 * in this case only the `name' field is valid.
3030 *
3031 * - libraries determined from the -l command line option (ie. -lbar),
3032 * in this case the `soname' field contains the basename of the located
3033 * file.
3034 *
3035 * Any shared object specified via the above two conventions must be recorded
3036 * as a needed dependency.
3037 *
3038 * - libraries specified as dependencies of those libraries already obtained
3039 * via the command line (ie. bar.so has a DT_NEEDED entry of fred.so.1),
3040 * in this case the `soname' field contains either a full pathname (if the
3041 * needed entry contained a `/'), or the basename of the located file.
3042 * These libraries are processed to verify symbol binding but are not
3043 * recorded as dependencies of the output file being generated.
3044 *
3045 * entry:
3046 * name - File name
3047 * soname - SONAME for needed sharable library, as described above
3048 * fd - Open file descriptor
3049 * elf - Open ELF handle
3050 * flags - FLG_IF_ flags applicable to file
3051 * ofl - Output file descriptor
3052 * rej - Rejection descriptor used to record rejection reason
3053 * ifl_ret - NULL, or address of pointer to receive reference to
3054 * resulting input descriptor for file. If ifl_ret is non-NULL,
3055 * the file cannot be an archive or it will be rejected.
3056 *
3057 * exit:
3058 * If a error occurs in examining the file, S_ERROR is returned.
3059 * If the file can be examined, but is not suitable, *rej is updated,
3060 * and 0 is returned. If the file is acceptable, 1 is returned, and if
3061 * ifl_ret is non-NULL, *ifl_ret is set to contain the pointer to the
3062 * resulting input descriptor.
3063 */
3064 uintptr_t
3067 {
3073 Rej_desc _rej;
3075 /*
3076 * If this file was not extracted from an archive obtain its device
3077 * information. This will be used to determine if the file has already
3078 * been processed (rather than simply comparing filenames, the device
3079 * information provides a quicker comparison and detects linked files).
3080 */
3086 }
3090 /*
3091 * If the caller has supplied a non-NULL ifl_ret, then
3092 * we cannot process archives, for there will be no
3093 * input file descriptor for us to return. In this case,
3094 * reject the attempt.
3095 */
3104 }
3106 }
3108 /*
3109 * Determine if we've already come across this archive file.
3110 */
3112 Aliste idx;
3119 /*
3120 * We've seen this file before so reuse the
3121 * original archive descriptor and discard the
3122 * new elf descriptor. Note that a file
3123 * descriptor is unnecessary, as the file is
3124 * already available in memory.
3125 */
3132 }
3133 }
3135 /*
3136 * As we haven't processed this file before establish a new
3137 * archive descriptor.
3138 */
3147 /*
3148 * Indicate that the ELF descriptor no longer requires a file
3149 * descriptor by reading the entire file. The file is already
3150 * read via the initial mmap(2) behind elf_begin(3elf), thus
3151 * this operation is effectively a no-op. However, a side-
3152 * effect is that the internal file descriptor, maintained in
3153 * the ELF descriptor, is set to -1. This setting will not
3154 * be compared with any file descriptor that is passed to
3155 * elf_begin(), should this archive, or one of the archive
3156 * members, be processed again from the command line or
3157 * because of a -z rescan.
3158 */
3161 name);
3163 }
3170 /*
3171 * Obtain the elf header so that we can determine what type of
3172 * elf ELF_K_ELF file this is.
3173 */
3177 /*
3178 * This can fail for a number of reasons. Typically
3179 * the object class is incorrect (ie. user is building
3180 * 64-bit but managed to point at 32-bit libraries).
3181 * Other ELF errors can include a truncated or corrupt
3182 * file. Try to get the best error message possible.
3183 */
3190 }
3197 }
3199 }
3201 /*
3202 * Determine if we've already come across this file.
3203 */
3206 Aliste idx;
3210 else
3213 /*
3214 * Traverse the appropriate file list and determine if
3215 * a dev/inode match is found.
3216 */
3218 /*
3219 * Ifl_desc generated via -Nneed, therefore no
3220 * actual file behind it.
3221 */
3229 /*
3230 * Disregard (skip) this image.
3231 */
3236 /*
3237 * If the file was explicitly defined on the
3238 * command line (this is always the case for
3239 * relocatable objects, and is true for shared
3240 * objects when they weren't specified via -l or
3241 * were dragged in as an implicit dependency),
3242 * then warn the user.
3243 */
3248 /*
3249 * Determine whether this is the same
3250 * file name as originally encountered
3251 * so as to provide the most
3252 * descriptive diagnostic.
3253 */
3254 errmsg =
3260 }
3264 }
3265 }
3267 /*
3268 * At this point, we know we need the file. Establish an input
3269 * file descriptor and continue processing.
3270 */
3277 /*
3278 * If -zignore is in effect, mark this file as a potential
3279 * candidate (the files use isn't actually determined until
3280 * symbol resolution and relocation processing are completed).
3281 */
3296 }
3298 /*
3299 * Record any additional shared object information.
3300 * If no soname is specified (eg. this file was
3301 * derived from a explicit filename declaration on the
3302 * command line, ie. bar.so) use the pathname.
3303 * This entry may be overridden if the files dynamic
3304 * section specifies an DT_SONAME value.
3305 */
3308 else
3311 /*
3312 * If direct bindings, lazy loading, group permissions,
3313 * or deferred dependencies need to be established, mark
3314 * this object.
3315 */
3328 /*
3329 * Determine whether this dependency requires a syminfo.
3330 */
3334 /*
3335 * Guidance: Use -z lazyload/nolazyload.
3336 * libc is exempt from this advice, because it cannot
3337 * be lazy loaded, and requests to do so are ignored.
3338 */
3344 }
3346 /*
3347 * Guidance: Use -B direct/nodirect or
3348 * -z direct/nodirect.
3349 */
3354 }
3366 }
3368 }
3379 }
3381 }
3388 }
3390 /*
3391 * Having successfully opened a file, set up the necessary elf structures to
3392 * process it further. This small section of processing is slightly different
3393 * from the elf initialization required to process a relocatable object from an
3394 * archive (see libs.c: ld_process_archive()).
3395 */
3396 uintptr_t
3399 {
3407 }
3409 /*
3410 * Determine whether the support library wishes to process this open.
3411 * The support library may return:
3412 * . a different ELF descriptor (in which case they should have
3413 * closed the original)
3414 * . a different file descriptor (in which case they should have
3415 * closed the original)
3416 * . a different path and file name (presumably associated with
3417 * a different file descriptor)
3418 *
3419 * A file descriptor of -1, or and ELF descriptor of zero indicates
3420 * the file should be ignored.
3421 */
3429 ifl_ret));
3430 }
3432 /*
3433 * Having successfully mapped a file, set up the necessary elf structures to
3434 * process it further. This routine is patterned after ld_process_open() and
3435 * is only called by ld.so.1(1) to process a relocatable object.
3436 */
3437 Ifl_desc *
3440 {
3448 }
3454 }
3456 /*
3457 * Process a required library (i.e. the dependency of a shared object).
3458 * Combine the directory and filename, check the resultant path size, and try
3459 * opening the pathname.
3460 */
3464 {
3470 /*
3471 * Determine the sizes of the directory and filename to insure we don't
3472 * exceed our buffer.
3473 */
3477 }
3478 dlen++;
3484 }
3486 /*
3487 * Build the entire pathname and try and open the file.
3488 */
3512 }
3513 }
3515 /*
3516 * Finish any library processing. Walk the list of so's that have been listed
3517 * as "included" by shared objects we have previously processed. Examine them,
3518 * without adding them as explicit dependents of this program, in order to
3519 * complete our symbol definition process. The search path rules are:
3520 *
3521 * - use any user supplied paths, i.e. LD_LIBRARY_PATH and -L, then
3522 *
3523 * - use any RPATH defined within the parent shared object, then
3524 *
3525 * - use the default directories, i.e. LIBPATH or -YP.
3526 */
3527 uintptr_t
3529 {
3530 Aliste idx1;
3534 /*
3535 * Make sure we are back in dynamic mode.
3536 */
3540 Aliste idx2;
3546 /*
3547 * See if this file has already been processed. At the time
3548 * this implicit dependency was determined there may still have
3549 * been more explicit dependencies to process. Note, if we ever
3550 * do parse the command line three times we would be able to
3551 * do all this checking when processing the dynamic section.
3552 */
3561 }
3562 }
3566 /*
3567 * If the current path name element embeds a "/", then it's to
3568 * be taken "as is", with no searching involved. Process all
3569 * "/" occurrences, so that we can deduce the base file name.
3570 */
3574 }
3594 Conv_reject_desc_buf_t rej_buf;
3604 }
3606 }
3608 /*
3609 * Now search for this file in any user defined directories.
3610 */
3617 }
3622 }
3623 }
3627 }
3628 }
3632 /*
3633 * Next use the local rules defined within the parent shared
3634 * object.
3635 */
3657 }
3663 }
3667 }
3670 }
3671 }
3675 /*
3676 * Finally try the default library search directories.
3677 */
3684 }
3689 }
3690 }
3694 }
3695 }
3699 /*
3700 * If we've got this far we haven't found the shared object.
3701 * If an object was found, but was rejected for some reason,
3702 * print a diagnostic to that effect, otherwise generate a
3703 * generic "not found" diagnostic.
3704 */
3706 Conv_reject_desc_buf_t rej_buf;
3717 }
3718 }
3720 /*
3721 * Finally, now that all objects have been input, make sure any version
3722 * requirements have been met.
3723 */
3725 }