1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1988 AT&T 24 * All Rights Reserved 25 * 26 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved. 27 * Copyright (c) 2012, Joyent, Inc. All rights reserved. 28 */ 29 30 /* 31 * Processing of relocatable objects and shared objects. 32 */ 33 34 #define ELF_TARGET_AMD64 35 #define ELF_TARGET_SPARC 36 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> 48 49 /* 50 * Decide if we can link against this input file. 51 */ 52 static int 53 ifl_verify(Ehdr *ehdr, Ofl_desc *ofl, Rej_desc *rej) 54 { 55 /* 56 * Check the validity of the elf header information for compatibility 57 * with this machine and our own internal elf library. 58 */ 59 if ((ehdr->e_machine != ld_targ.t_m.m_mach) && 60 ((ehdr->e_machine != ld_targ.t_m.m_machplus) && 61 ((ehdr->e_flags & ld_targ.t_m.m_flagsplus) == 0))) { 62 rej->rej_type = SGS_REJ_MACH; 63 rej->rej_info = (uint_t)ehdr->e_machine; 64 return (0); 65 } 66 if (ehdr->e_ident[EI_DATA] != ld_targ.t_m.m_data) { 67 rej->rej_type = SGS_REJ_DATA; 68 rej->rej_info = (uint_t)ehdr->e_ident[EI_DATA]; 69 return (0); 70 } 71 if (ehdr->e_version > ofl->ofl_dehdr->e_version) { 72 rej->rej_type = SGS_REJ_VERSION; 73 rej->rej_info = (uint_t)ehdr->e_version; 74 return (0); 75 } 76 return (1); 77 } 78 79 /* 80 * Check sanity of file header and allocate an infile descriptor 81 * for the file being processed. 82 */ 83 static Ifl_desc * 84 ifl_setup(const char *name, Ehdr *ehdr, Elf *elf, Word flags, Ofl_desc *ofl, 85 Rej_desc *rej) 86 { 87 Ifl_desc *ifl; 88 Rej_desc _rej = { 0 }; 89 90 if (ifl_verify(ehdr, ofl, &_rej) == 0) { 91 _rej.rej_name = name; 92 DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej, 93 ld_targ.t_m.m_mach)); 94 if (rej->rej_type == 0) { 95 *rej = _rej; 96 rej->rej_name = strdup(_rej.rej_name); 97 } 98 return (0); 99 } 100 101 if ((ifl = libld_calloc(1, sizeof (Ifl_desc))) == NULL) 102 return ((Ifl_desc *)S_ERROR); 103 ifl->ifl_name = name; 104 ifl->ifl_ehdr = ehdr; 105 ifl->ifl_elf = elf; 106 ifl->ifl_flags = flags; 107 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 */ 115 if ((ehdr->e_shnum == 0) && (ehdr->e_shoff != 0)) { 116 Elf_Scn *scn; 117 Shdr *shdr0; 118 119 if ((scn = elf_getscn(elf, 0)) == NULL) { 120 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSCN), 121 name); 122 return ((Ifl_desc *)S_ERROR); 123 } 124 if ((shdr0 = elf_getshdr(scn)) == NULL) { 125 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR), 126 name); 127 return ((Ifl_desc *)S_ERROR); 128 } 129 ifl->ifl_shnum = (Word)shdr0->sh_size; 130 if (ehdr->e_shstrndx == SHN_XINDEX) 131 ifl->ifl_shstrndx = shdr0->sh_link; 132 else 133 ifl->ifl_shstrndx = ehdr->e_shstrndx; 134 } else { 135 ifl->ifl_shnum = ehdr->e_shnum; 136 ifl->ifl_shstrndx = ehdr->e_shstrndx; 137 } 138 139 if ((ifl->ifl_isdesc = libld_calloc(ifl->ifl_shnum, 140 sizeof (Is_desc *))) == NULL) 141 return ((Ifl_desc *)S_ERROR); 142 143 /* 144 * Record this new input file on the shared object or relocatable 145 * object input file list. 146 */ 147 if (ifl->ifl_ehdr->e_type == ET_DYN) { 148 if (aplist_append(&ofl->ofl_sos, ifl, AL_CNT_OFL_LIBS) == NULL) 149 return ((Ifl_desc *)S_ERROR); 150 } else { 151 if (aplist_append(&ofl->ofl_objs, ifl, AL_CNT_OFL_OBJS) == NULL) 152 return ((Ifl_desc *)S_ERROR); 153 } 154 155 return (ifl); 156 } 157 158 /* 159 * Process a generic section. The appropriate section information is added 160 * to the files input descriptor list. 161 */ 162 static uintptr_t 163 process_section(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 164 Word ndx, int ident, Ofl_desc *ofl) 165 { 166 Is_desc *isp; 167 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 */ 173 if ((isp = libld_calloc(sizeof (Is_desc), 1)) == NULL) 174 return (S_ERROR); 175 isp->is_shdr = shdr; 176 isp->is_file = ifl; 177 isp->is_name = name; 178 isp->is_scnndx = ndx; 179 isp->is_flags = FLG_IS_EXTERNAL; 180 isp->is_keyident = ident; 181 182 if ((isp->is_indata = elf_getdata(scn, NULL)) == NULL) { 183 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETDATA), 184 ifl->ifl_name); 185 return (0); 186 } 187 188 if ((shdr->sh_flags & SHF_EXCLUDE) && 189 ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) { 190 isp->is_flags |= FLG_IS_DISCARD; 191 } 192 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 */ 200 ifl->ifl_isdesc[ndx] = isp; 201 202 if (ident) { 203 if (shdr->sh_flags & ALL_SHF_ORDER) { 204 isp->is_flags |= FLG_IS_ORDERED; 205 ifl->ifl_flags |= FLG_IF_ORDERED; 206 } 207 isp->is_flags |= FLG_IS_PLACE; 208 } 209 return (1); 210 } 211 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 238 sf1_cap(Ofl_desc *ofl, Xword val, Ifl_desc *ifl, Is_desc *cisp) 239 { 240 #define FP_FLAGS (SF1_SUNW_FPKNWN | SF1_SUNW_FPUSED) 241 242 Xword badval; 243 244 /* 245 * If a mapfile has established definitions to override any object 246 * capabilities, ignore any new object capabilities. 247 */ 248 if (ofl->ofl_flags1 & FLG_OF1_OVSFCAP1) { 249 DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_IGNORED, 250 CA_SUNW_SF_1, val, ld_targ.t_m.m_mach)); 251 return; 252 } 253 254 #if !defined(_ELF64) 255 if (ifl && (ifl->ifl_ehdr->e_type == ET_REL)) { 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 */ 261 if (val & SF1_SUNW_ADDR32) { 262 ld_eprintf(ofl, ERR_WARNING, 263 MSG_INTL(MSG_FIL_INADDR32SF1), ifl->ifl_name, 264 EC_WORD(cisp->is_scnndx), cisp->is_name); 265 val &= ~SF1_SUNW_ADDR32; 266 } 267 } 268 #endif 269 /* 270 * If this object doesn't specify any capabilities, ignore it, and 271 * leave the state as is. 272 */ 273 if (val == 0) 274 return; 275 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 */ 280 if ((badval = (val & ~SF1_SUNW_MASK)) != 0) { 281 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_BADSF1), 282 ifl->ifl_name, EC_WORD(cisp->is_scnndx), cisp->is_name, 283 EC_XWORD(badval)); 284 val &= SF1_SUNW_MASK; 285 } 286 if ((val & FP_FLAGS) == SF1_SUNW_FPUSED) { 287 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_BADSF1), 288 ifl->ifl_name, EC_WORD(cisp->is_scnndx), cisp->is_name, 289 EC_XWORD(val)); 290 return; 291 } 292 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 */ 297 if (ifl->ifl_ehdr->e_type != ET_REL) { 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 */ 308 if ((val & SF1_SUNW_ADDR32) && (ofl->ofl_flags & FLG_OF_EXEC) && 309 ((ofl->ofl_ocapset.oc_sf_1.cm_val & 310 SF1_SUNW_ADDR32) == 0)) { 311 ld_eprintf(ofl, ERR_WARNING, 312 MSG_INTL(MSG_FIL_EXADDR32SF1), ifl->ifl_name, 313 EC_WORD(cisp->is_scnndx), cisp->is_name); 314 } 315 #endif 316 return; 317 } 318 319 if (DBG_ENABLED) { 320 Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_CURRENT, CA_SUNW_SF_1, 321 ofl->ofl_ocapset.oc_sf_1.cm_val, ld_targ.t_m.m_mach); 322 Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_NEW, CA_SUNW_SF_1, 323 val, ld_targ.t_m.m_mach); 324 } 325 326 /* 327 * Determine the resolution of the present frame pointer and the 328 * new input relocatable objects frame pointer. 329 */ 330 if ((ofl->ofl_ocapset.oc_sf_1.cm_val & FP_FLAGS) == FP_FLAGS) { 331 /* 332 * If the new relocatable object isn't using a frame pointer, 333 * reduce the present state to unused. 334 */ 335 if ((val & FP_FLAGS) != FP_FLAGS) 336 ofl->ofl_ocapset.oc_sf_1.cm_val &= ~SF1_SUNW_FPUSED; 337 338 /* 339 * Having processed the frame pointer bits, remove them from 340 * the value so they don't get OR'd in below. 341 */ 342 val &= ~FP_FLAGS; 343 344 } else if ((ofl->ofl_ocapset.oc_sf_1.cm_val & SF1_SUNW_FPKNWN) == 0) { 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 */ 350 ofl->ofl_ocapset.oc_sf_1.cm_val &= ~FP_FLAGS; 351 } else { 352 /* Do not take the frame pointer flags from the object */ 353 val &= ~FP_FLAGS; 354 } 355 356 ofl->ofl_ocapset.oc_sf_1.cm_val |= val; 357 358 DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_RESOLVED, 359 CA_SUNW_SF_1, ofl->ofl_ocapset.oc_sf_1.cm_val, ld_targ.t_m.m_mach)); 360 361 #undef FP_FLAGS 362 } 363 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 371 hw_cap(Ofl_desc *ofl, Xword tag, Xword val) 372 { 373 elfcap_mask_t *hwcap; 374 ofl_flag_t flags1; 375 376 if (tag == CA_SUNW_HW_1) { 377 hwcap = &ofl->ofl_ocapset.oc_hw_1.cm_val; 378 flags1 = FLG_OF1_OVHWCAP1; 379 } else { 380 hwcap = &ofl->ofl_ocapset.oc_hw_2.cm_val; 381 flags1 = FLG_OF1_OVHWCAP2; 382 } 383 384 /* 385 * If a mapfile has established definitions to override any object 386 * capabilities, ignore any new object capabilities. 387 */ 388 if (ofl->ofl_flags1 & flags1) { 389 DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_IGNORED, 390 tag, val, ld_targ.t_m.m_mach)); 391 return; 392 } 393 394 /* 395 * If this object doesn't specify any capabilities, ignore it, and 396 * leave the state as is. 397 */ 398 if (val == 0) 399 return; 400 401 if (DBG_ENABLED) { 402 Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_CURRENT, CA_SUNW_HW_1, 403 ofl->ofl_ocapset.oc_hw_1.cm_val, ld_targ.t_m.m_mach); 404 Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_NEW, CA_SUNW_HW_1, 405 val, ld_targ.t_m.m_mach); 406 } 407 408 *hwcap |= val; 409 410 DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, DBG_STATE_RESOLVED, tag, 411 *hwcap, ld_targ.t_m.m_mach)); 412 } 413 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 419 str_cap(Ofl_desc *ofl, char *pstr, ofl_flag_t flags, Xword tag, Caplist *list) 420 { 421 Capstr *capstr; 422 Aliste idx; 423 Boolean found = FALSE; 424 425 /* 426 * If a mapfile has established definitions to override this capability, 427 * ignore any new capability. 428 */ 429 if (ofl->ofl_flags1 & flags) { 430 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_IGNORED, 431 tag, pstr)); 432 return; 433 } 434 435 for (ALIST_TRAVERSE(list->cl_val, idx, capstr)) { 436 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, 437 DBG_STATE_CURRENT, tag, capstr->cs_str)); 438 if (strcmp(capstr->cs_str, pstr) == 0) 439 found = TRUE; 440 } 441 442 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_NEW, tag, pstr)); 443 444 if (found == FALSE) { 445 if ((capstr = alist_append(&list->cl_val, NULL, 446 sizeof (Capstr), AL_CNT_CAP_NAMES)) == NULL) { 447 ofl->ofl_flags |= FLG_OF_FATAL; 448 return; 449 } 450 capstr->cs_str = pstr; 451 } 452 453 if (DBG_ENABLED) { 454 for (ALIST_TRAVERSE(list->cl_val, idx, capstr)) { 455 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, 456 DBG_STATE_RESOLVED, tag, capstr->cs_str)); 457 } 458 } 459 } 460 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 470 id_cap(Ofl_desc *ofl, char *pstr, oc_flag_t flags) 471 { 472 Objcapset *ocapset = &ofl->ofl_ocapset; 473 474 if (ocapset->oc_id.cs_str) { 475 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_CURRENT, 476 CA_SUNW_ID, ocapset->oc_id.cs_str)); 477 478 if ((ocapset->oc_flags & FLG_OCS_USRDEFID) || 479 ((flags & FLG_OCS_USRDEFID) == 0)) { 480 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, 481 DBG_STATE_IGNORED, CA_SUNW_ID, pstr)); 482 return; 483 } 484 } 485 486 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_NEW, 487 CA_SUNW_ID, pstr)); 488 489 ocapset->oc_id.cs_str = pstr; 490 ocapset->oc_flags |= flags; 491 492 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, DBG_STATE_RESOLVED, 493 CA_SUNW_ID, pstr)); 494 } 495 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 505 ld_cap_move_symtoobj(Ofl_desc *ofl) 506 { 507 Cap_group *cgp; 508 Aliste idx1; 509 510 for (APLIST_TRAVERSE(ofl->ofl_capgroups, idx1, cgp)) { 511 Objcapset *scapset = &cgp->cg_set; 512 Capstr *capstr; 513 Aliste idx2; 514 515 if (scapset->oc_id.cs_str) { 516 if (scapset->oc_flags & FLG_OCS_USRDEFID) 517 id_cap(ofl, scapset->oc_id.cs_str, 518 scapset->oc_flags); 519 } 520 if (scapset->oc_plat.cl_val) { 521 for (ALIST_TRAVERSE(scapset->oc_plat.cl_val, idx2, 522 capstr)) { 523 str_cap(ofl, capstr->cs_str, FLG_OF1_OVPLATCAP, 524 CA_SUNW_PLAT, &ofl->ofl_ocapset.oc_plat); 525 } 526 } 527 if (scapset->oc_mach.cl_val) { 528 for (ALIST_TRAVERSE(scapset->oc_mach.cl_val, idx2, 529 capstr)) { 530 str_cap(ofl, capstr->cs_str, FLG_OF1_OVMACHCAP, 531 CA_SUNW_MACH, &ofl->ofl_ocapset.oc_mach); 532 } 533 } 534 if (scapset->oc_hw_2.cm_val) 535 hw_cap(ofl, CA_SUNW_HW_2, scapset->oc_hw_2.cm_val); 536 537 if (scapset->oc_hw_1.cm_val) 538 hw_cap(ofl, CA_SUNW_HW_1, scapset->oc_hw_1.cm_val); 539 540 if (scapset->oc_sf_1.cm_val) 541 sf1_cap(ofl, scapset->oc_sf_1.cm_val, NULL, NULL); 542 } 543 } 544 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 */ 553 static Cap_group * 554 get_cap_group(Objcapset *ocapset, Word cnum, Ofl_desc *ofl, Is_desc *isp) 555 { 556 Aliste idx; 557 Cap_group *cgp; 558 Word ccnum = cnum; 559 560 /* 561 * If the new capabilities contains a CA_SUNW_ID, drop the count of the 562 * number of comparable items. 563 */ 564 if (ocapset->oc_id.cs_str) 565 ccnum--; 566 567 /* 568 * Traverse the existing symbols capabilities groups. 569 */ 570 for (APLIST_TRAVERSE(ofl->ofl_capgroups, idx, cgp)) { 571 Word onum = cgp->cg_num; 572 Alist *calp, *oalp; 573 574 if (cgp->cg_set.oc_id.cs_str) 575 onum--; 576 577 if (onum != ccnum) 578 continue; 579 580 if (cgp->cg_set.oc_hw_1.cm_val != ocapset->oc_hw_1.cm_val) 581 continue; 582 if (cgp->cg_set.oc_sf_1.cm_val != ocapset->oc_sf_1.cm_val) 583 continue; 584 if (cgp->cg_set.oc_hw_2.cm_val != ocapset->oc_hw_2.cm_val) 585 continue; 586 587 calp = cgp->cg_set.oc_plat.cl_val; 588 oalp = ocapset->oc_plat.cl_val; 589 if ((calp == NULL) && oalp) 590 continue; 591 if (calp && ((oalp == NULL) || cap_names_match(calp, oalp))) 592 continue; 593 594 calp = cgp->cg_set.oc_mach.cl_val; 595 oalp = ocapset->oc_mach.cl_val; 596 if ((calp == NULL) && oalp) 597 continue; 598 if (calp && ((oalp == NULL) || cap_names_match(calp, oalp))) 599 continue; 600 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 */ 608 if (aplist_append(&(cgp->cg_secs), isp, 609 AL_CNT_CAP_SECS) == NULL) 610 return (NULL); 611 return (cgp); 612 } 613 614 /* 615 * If a capabilities group is not found, create a new one. 616 */ 617 if (((cgp = libld_calloc(sizeof (Cap_group), 1)) == NULL) || 618 (aplist_append(&(ofl->ofl_capgroups), cgp, 619 AL_CNT_CAP_DESCS) == NULL)) 620 return (NULL); 621 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 */ 628 if ((isp->is_file->ifl_flags & FLG_IF_OTOSCAP) && 629 (ocapset->oc_id.cs_str == NULL)) { 630 size_t len; 631 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 */ 637 len = MSG_STR_CAPGROUPID_SIZE + CONV_INV_BUFSIZE; 638 if ((ocapset->oc_id.cs_str = libld_malloc(len)) == NULL) 639 return (NULL); 640 641 (void) snprintf(ocapset->oc_id.cs_str, len, 642 MSG_ORIG(MSG_STR_CAPGROUPID), 643 aplist_nitems(ofl->ofl_capgroups)); 644 cnum++; 645 } 646 647 cgp->cg_set = *ocapset; 648 cgp->cg_num = cnum; 649 650 /* 651 * Null the callers alist's as they've effectively been transferred 652 * to this new Cap_group. 653 */ 654 ocapset->oc_plat.cl_val = ocapset->oc_mach.cl_val = NULL; 655 656 /* 657 * Keep track of which input section, and hence input file, established 658 * this group. 659 */ 660 if (aplist_append(&(cgp->cg_secs), isp, AL_CNT_CAP_SECS) == NULL) 661 return (NULL); 662 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 */ 668 ofl->ofl_capsymcnt += (cnum + 1); 669 return (cgp); 670 } 671 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 695 ld_cap_add_family(Ofl_desc *ofl, Sym_desc *lsdp, Sym_desc *csdp, Cap_group *cgp, 696 APlist **csyms) 697 { 698 Cap_avlnode qcav, *cav; 699 avl_tree_t *avlt; 700 avl_index_t where = 0; 701 Cap_sym *mcsp; 702 Aliste idx; 703 704 /* 705 * Make sure the capability families have an initialized AVL tree. 706 */ 707 if ((avlt = ofl->ofl_capfamilies) == NULL) { 708 if ((avlt = libld_calloc(sizeof (avl_tree_t), 1)) == NULL) 709 return (S_ERROR); 710 avl_create(avlt, &ld_sym_avl_comp, sizeof (Cap_avlnode), 711 SGSOFFSETOF(Cap_avlnode, cn_symavlnode.sav_node)); 712 ofl->ofl_capfamilies = avlt; 713 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 */ 719 ofl->ofl_capchaincnt = 1; 720 } 721 722 /* 723 * Determine whether a family already exists, and if not, create one 724 * using the lead family symbol. 725 */ 726 qcav.cn_symavlnode.sav_hash = (Word)elf_hash(lsdp->sd_name); 727 qcav.cn_symavlnode.sav_name = lsdp->sd_name; 728 729 if ((cav = avl_find(avlt, &qcav, &where)) == NULL) { 730 if ((cav = libld_calloc(sizeof (Cap_avlnode), 1)) == NULL) 731 return (S_ERROR); 732 cav->cn_symavlnode.sav_hash = qcav.cn_symavlnode.sav_hash; 733 cav->cn_symavlnode.sav_name = qcav.cn_symavlnode.sav_name; 734 cav->cn_symavlnode.sav_sdp = lsdp; 735 736 avl_insert(avlt, cav, where); 737 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 */ 743 ofl->ofl_capchaincnt += 2; 744 } 745 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 */ 751 if (cgp == NULL) { 752 if ((lsdp != csdp) && (aplist_append(&cav->cn_aliases, csdp, 753 AL_CNT_CAP_ALIASES) == NULL)) 754 return (S_ERROR); 755 756 return (0); 757 } 758 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 */ 764 for (APLIST_TRAVERSE(cav->cn_members, idx, mcsp)) { 765 Sym_desc *msdp; 766 767 if (cgp != mcsp->cs_group) 768 continue; 769 770 /* 771 * Diagnose that a multiple symbol definition exists. 772 */ 773 msdp = mcsp->cs_sdp; 774 775 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_CAP_MULDEF), 776 demangle(lsdp->sd_name)); 777 ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_CAP_MULDEFSYMS), 778 msdp->sd_file->ifl_name, msdp->sd_name, 779 csdp->sd_file->ifl_name, csdp->sd_name); 780 } 781 782 /* 783 * Add this capabilities symbol member to the family. 784 */ 785 if (((mcsp = libld_malloc(sizeof (Cap_sym))) == NULL) || 786 (aplist_append(&cav->cn_members, mcsp, AL_CNT_CAP_MEMS) == NULL)) 787 return (S_ERROR); 788 789 mcsp->cs_sdp = csdp; 790 mcsp->cs_group = cgp; 791 792 /* 793 * When creating a dynamic object, capability family members are 794 * maintained in a .SUNW_capchain. Account for this family member. 795 */ 796 ofl->ofl_capchaincnt++; 797 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 */ 805 if (csyms && (aplist_append(csyms, mcsp, AL_CNT_CAP_SYMS) == NULL)) 806 return (S_ERROR); 807 808 return (0); 809 } 810 811 /* 812 * Process a SHT_SUNW_cap capabilities section. 813 */ 814 static uintptr_t 815 process_cap(Ofl_desc *ofl, Ifl_desc *ifl, Is_desc *cisp) 816 { 817 Objcapset ocapset = { 0 }; 818 Cap_desc *cdp; 819 Cap *data, *cdata; 820 char *strs; 821 Word ndx, cnum; 822 int objcapndx, descapndx, symcapndx; 823 int nulls, capstrs = 0; 824 825 /* 826 * Determine the capabilities data and size. 827 */ 828 cdata = (Cap *)cisp->is_indata->d_buf; 829 cnum = (Word)(cisp->is_shdr->sh_size / cisp->is_shdr->sh_entsize); 830 831 if ((cdata == NULL) || (cnum == 0)) 832 return (0); 833 834 DBG_CALL(Dbg_cap_sec_title(ofl->ofl_lml, ifl->ifl_name)); 835 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 */ 856 objcapndx = 0; 857 descapndx = symcapndx = -1; 858 nulls = 0; 859 860 for (ndx = 0, data = cdata; ndx < cnum; ndx++, data++) { 861 switch (data->c_tag) { 862 case CA_SUNW_NULL: 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 */ 868 if (nulls++ == 0) { 869 if (ndx == 0) 870 objcapndx = -1; 871 } else if ((symcapndx == -1) && (descapndx != -1)) 872 symcapndx = descapndx; 873 874 break; 875 876 case CA_SUNW_PLAT: 877 case CA_SUNW_MACH: 878 case CA_SUNW_ID: 879 capstrs++; 880 /* FALLTHROUGH */ 881 882 case CA_SUNW_HW_1: 883 case CA_SUNW_SF_1: 884 case CA_SUNW_HW_2: 885 /* 886 * If this is the start of a new group, save it. 887 */ 888 if (descapndx == -1) 889 descapndx = ndx; 890 break; 891 892 default: 893 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_UNKCAP), 894 ifl->ifl_name, EC_WORD(cisp->is_scnndx), 895 cisp->is_name, data->c_tag); 896 } 897 } 898 899 /* 900 * If a string capabilities entry has been found, the capabilities 901 * section must reference the associated string table. 902 */ 903 if (capstrs) { 904 Word info = cisp->is_shdr->sh_info; 905 906 if ((info == 0) || (info > ifl->ifl_shnum)) { 907 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO), 908 ifl->ifl_name, EC_WORD(cisp->is_scnndx), 909 cisp->is_name, EC_XWORD(info)); 910 return (S_ERROR); 911 } 912 strs = (char *)ifl->ifl_isdesc[info]->is_indata->d_buf; 913 } 914 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 */ 929 if ((objcapndx == 0) && 930 ((symcapndx != -1) || ((ofl->ofl_flags & FLG_OF_OTOSCAP) == 0))) { 931 for (ndx = 0, data = cdata; ndx < cnum; ndx++, data++) { 932 /* 933 * Object capabilities end at the first null. 934 */ 935 if (data->c_tag == CA_SUNW_NULL) 936 break; 937 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 */ 945 if (data->c_tag == CA_SUNW_SF_1) { 946 sf1_cap(ofl, data->c_un.c_val, ifl, cisp); 947 continue; 948 } 949 950 /* 951 * The remaining capability types must come from a 952 * relocatable object in order to contribute to the 953 * output. 954 */ 955 if (ifl->ifl_ehdr->e_type != ET_REL) 956 continue; 957 958 switch (data->c_tag) { 959 case CA_SUNW_HW_1: 960 case CA_SUNW_HW_2: 961 hw_cap(ofl, data->c_tag, data->c_un.c_val); 962 break; 963 964 case CA_SUNW_PLAT: 965 str_cap(ofl, strs + data->c_un.c_ptr, 966 FLG_OF1_OVPLATCAP, CA_SUNW_PLAT, 967 &ofl->ofl_ocapset.oc_plat); 968 break; 969 970 case CA_SUNW_MACH: 971 str_cap(ofl, strs + data->c_un.c_ptr, 972 FLG_OF1_OVMACHCAP, CA_SUNW_MACH, 973 &ofl->ofl_ocapset.oc_mach); 974 break; 975 976 case CA_SUNW_ID: 977 id_cap(ofl, strs + data->c_un.c_ptr, 978 FLG_OCS_USRDEFID); 979 break; 980 981 default: 982 assert(0); /* Unknown capability type */ 983 } 984 } 985 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 */ 991 if ((symcapndx == -1) && 992 ((ofl->ofl_flags & FLG_OF_OTOSCAP) == 0)) 993 return (1); 994 } 995 996 /* 997 * If these capabilities don't originate from a relocatable object 998 * there's no further processing required. 999 */ 1000 if (ifl->ifl_ehdr->e_type != ET_REL) 1001 return (1); 1002 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 */ 1009 if ((objcapndx == 0) && 1010 (symcapndx == -1) && (ofl->ofl_flags & FLG_OF_OTOSCAP)) 1011 ifl->ifl_flags |= FLG_IF_OTOSCAP; 1012 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 */ 1020 if (((cdp = libld_calloc(sizeof (Cap_desc), 1)) == NULL) || 1021 (aplist_append(&(cdp->ca_groups), NULL, cnum) == NULL)) 1022 return (S_ERROR); 1023 1024 /* 1025 * Clear the allocated APlist data array, and assign the number of 1026 * items as the total number of array items. 1027 */ 1028 (void) memset(&cdp->ca_groups->apl_data[0], 0, 1029 (cnum * sizeof (void *))); 1030 cdp->ca_groups->apl_nitems = cnum; 1031 1032 ifl->ifl_caps = cdp; 1033 1034 /* 1035 * Traverse the capabilities data, unpacking the data into a 1036 * capabilities set. Process each capabilities set as a unique group. 1037 */ 1038 descapndx = -1; 1039 nulls = 0; 1040 1041 for (ndx = 0, data = cdata; ndx < cnum; ndx++, data++) { 1042 Capstr *capstr; 1043 1044 switch (data->c_tag) { 1045 case CA_SUNW_NULL: 1046 nulls++; 1047 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 */ 1061 if (descapndx != -1) { 1062 if ((nulls > 1) || 1063 (ifl->ifl_flags & FLG_IF_OTOSCAP)) { 1064 APlist *alp = cdp->ca_groups; 1065 1066 if ((alp->apl_data[descapndx] = 1067 get_cap_group(&ocapset, 1068 (ndx - descapndx), ofl, 1069 cisp)) == NULL) 1070 return (S_ERROR); 1071 } 1072 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 */ 1084 ocapset.oc_hw_1.cm_val = 1085 ocapset.oc_sf_1.cm_val = 1086 ocapset.oc_hw_2.cm_val = 0; 1087 if (ocapset.oc_plat.cl_val) { 1088 free((void *)ocapset.oc_plat.cl_val); 1089 ocapset.oc_plat.cl_val = NULL; 1090 } 1091 if (ocapset.oc_mach.cl_val) { 1092 free((void *)ocapset.oc_mach.cl_val); 1093 ocapset.oc_mach.cl_val = NULL; 1094 } 1095 descapndx = -1; 1096 } 1097 continue; 1098 1099 case CA_SUNW_HW_1: 1100 ocapset.oc_hw_1.cm_val = data->c_un.c_val; 1101 DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, 1102 DBG_STATE_ORIGINAL, CA_SUNW_HW_1, 1103 ocapset.oc_hw_1.cm_val, ld_targ.t_m.m_mach)); 1104 break; 1105 1106 case CA_SUNW_SF_1: 1107 ocapset.oc_sf_1.cm_val = data->c_un.c_val; 1108 DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, 1109 DBG_STATE_ORIGINAL, CA_SUNW_SF_1, 1110 ocapset.oc_sf_1.cm_val, ld_targ.t_m.m_mach)); 1111 break; 1112 1113 case CA_SUNW_HW_2: 1114 ocapset.oc_hw_2.cm_val = data->c_un.c_val; 1115 DBG_CALL(Dbg_cap_val_entry(ofl->ofl_lml, 1116 DBG_STATE_ORIGINAL, CA_SUNW_HW_2, 1117 ocapset.oc_hw_2.cm_val, ld_targ.t_m.m_mach)); 1118 break; 1119 1120 case CA_SUNW_PLAT: 1121 if ((capstr = alist_append(&ocapset.oc_plat.cl_val, 1122 NULL, sizeof (Capstr), AL_CNT_CAP_NAMES)) == NULL) 1123 return (S_ERROR); 1124 capstr->cs_str = strs + data->c_un.c_ptr; 1125 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, 1126 DBG_STATE_ORIGINAL, CA_SUNW_PLAT, capstr->cs_str)); 1127 break; 1128 1129 case CA_SUNW_MACH: 1130 if ((capstr = alist_append(&ocapset.oc_mach.cl_val, 1131 NULL, sizeof (Capstr), AL_CNT_CAP_NAMES)) == NULL) 1132 return (S_ERROR); 1133 capstr->cs_str = strs + data->c_un.c_ptr; 1134 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, 1135 DBG_STATE_ORIGINAL, CA_SUNW_MACH, capstr->cs_str)); 1136 break; 1137 1138 case CA_SUNW_ID: 1139 ocapset.oc_id.cs_str = strs + data->c_un.c_ptr; 1140 DBG_CALL(Dbg_cap_ptr_entry(ofl->ofl_lml, 1141 DBG_STATE_ORIGINAL, CA_SUNW_ID, 1142 ocapset.oc_id.cs_str)); 1143 break; 1144 } 1145 1146 /* 1147 * Save the start of this new group. 1148 */ 1149 if (descapndx == -1) 1150 descapndx = ndx; 1151 } 1152 return (1); 1153 } 1154 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 1163 process_capinfo(Ofl_desc *ofl, Ifl_desc *ifl, Is_desc *isp) 1164 { 1165 Cap_desc *cdp = ifl->ifl_caps; 1166 Capinfo *capinfo = isp->is_indata->d_buf; 1167 Shdr *shdr = isp->is_shdr; 1168 Word cndx, capinfonum; 1169 1170 capinfonum = (Word)(shdr->sh_size / shdr->sh_entsize); 1171 1172 if ((cdp == NULL) || (capinfo == NULL) || (capinfonum == 0)) 1173 return (0); 1174 1175 for (cndx = 1, capinfo++; cndx < capinfonum; cndx++, capinfo++) { 1176 Sym_desc *sdp, *lsdp; 1177 Word lndx; 1178 uchar_t gndx; 1179 1180 if ((gndx = (uchar_t)ELF_C_GROUP(*capinfo)) == 0) 1181 continue; 1182 lndx = (Word)ELF_C_SYM(*capinfo); 1183 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 */ 1191 if ((sdp = ifl->ifl_oldndx[cndx]) == NULL) { 1192 ld_eprintf(ofl, ERR_WARNING, 1193 MSG_INTL(MSG_CAPINFO_INVALSYM), ifl->ifl_name, 1194 EC_WORD(isp->is_scnndx), isp->is_name, cndx, 1195 MSG_INTL(MSG_STR_UNKNOWN)); 1196 continue; 1197 } 1198 if ((lndx == 0) || (lndx >= ifl->ifl_symscnt) || 1199 ((lsdp = ifl->ifl_oldndx[lndx]) == NULL) || 1200 (ELF_ST_BIND(lsdp->sd_sym->st_info) != STB_GLOBAL)) { 1201 ld_eprintf(ofl, ERR_WARNING, 1202 MSG_INTL(MSG_CAPINFO_INVALLEAD), ifl->ifl_name, 1203 EC_WORD(isp->is_scnndx), isp->is_name, cndx, lsdp ? 1204 demangle(lsdp->sd_name) : MSG_INTL(MSG_STR_UNKNOWN), 1205 lndx); 1206 continue; 1207 } 1208 1209 /* 1210 * Indicate that this is a capabilities symbol. 1211 */ 1212 sdp->sd_flags |= FLG_SY_CAP; 1213 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 */ 1220 if (gndx == CAPINFO_SUNW_GLOB) { 1221 if (ld_cap_add_family(ofl, lsdp, sdp, 1222 NULL, NULL) == S_ERROR) 1223 return (S_ERROR); 1224 continue; 1225 } 1226 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 */ 1234 ofl->ofl_caploclcnt++; 1235 if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) && 1236 (st_insert(ofl->ofl_dynstrtab, sdp->sd_name) == -1)) 1237 return (S_ERROR); 1238 1239 /* 1240 * As we're tracking this local symbol as a capabilities symbol, 1241 * reduce the local symbol count to compensate. 1242 */ 1243 ofl->ofl_locscnt--; 1244 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 */ 1253 if (lsdp->sd_flags & FLG_SY_NODYNSORT) { 1254 Sym *lsym = lsdp->sd_sym; 1255 uchar_t ltype = ELF_ST_TYPE(lsym->st_info); 1256 1257 DYNSORT_COUNT(lsdp, lsym, ltype, --); 1258 lsdp->sd_flags |= FLG_SY_NODYNSORT; 1259 } 1260 1261 /* 1262 * Track this family member, together with its associated group. 1263 */ 1264 if (ld_cap_add_family(ofl, lsdp, sdp, 1265 cdp->ca_groups->apl_data[gndx], NULL) == S_ERROR) 1266 return (S_ERROR); 1267 } 1268 1269 return (0); 1270 } 1271 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 */ 1280 process_input(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1281 Word ndx, int ident, Ofl_desc *ofl) 1282 { 1283 return (process_section(name, ifl, shdr, scn, ndx, 1284 ld_targ.t_id.id_null, ofl)); 1285 } 1286 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 */ 1295 process_reloc(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1296 Word ndx, int ident, Ofl_desc *ofl) 1297 { 1298 if (process_section(name, ifl, 1299 shdr, scn, ndx, ld_targ.t_id.id_null, ofl) == S_ERROR) 1300 return (S_ERROR); 1301 1302 if (ifl->ifl_ehdr->e_type == ET_REL) { 1303 if (shdr->sh_entsize && (shdr->sh_entsize <= shdr->sh_size)) 1304 /* LINTED */ 1305 ofl->ofl_relocincnt += 1306 (Word)(shdr->sh_size / shdr->sh_entsize); 1307 } else if (ofl->ofl_flags & FLG_OF_EXEC) { 1308 if (aplist_append(&ifl->ifl_relsect, ifl->ifl_isdesc[ndx], 1309 AL_CNT_IFL_RELSECS) == NULL) 1310 return (S_ERROR); 1311 } 1312 return (1); 1313 } 1314 1315 /* 1316 * Process a string table section. A valid section contains an initial and 1317 * final null byte. 1318 */ 1319 static uintptr_t 1320 process_strtab(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1321 Word ndx, int ident, Ofl_desc *ofl) 1322 { 1323 char *data; 1324 size_t size; 1325 Is_desc *isp; 1326 uintptr_t error; 1327 1328 /* 1329 * Never include .stab.excl sections in any output file. 1330 * If the -s flag has been specified strip any .stab sections. 1331 */ 1332 if (((ofl->ofl_flags & FLG_OF_STRIP) && ident && 1333 (strncmp(name, MSG_ORIG(MSG_SCN_STAB), MSG_SCN_STAB_SIZE) == 0)) || 1334 (strcmp(name, MSG_ORIG(MSG_SCN_STABEXCL)) == 0) && ident) 1335 return (1); 1336 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 */ 1342 if ((ident != ld_targ.t_id.id_null) && 1343 (strcmp(name, MSG_ORIG(MSG_SCN_STRTAB)) == 0)) 1344 ident = ld_targ.t_id.id_null; 1345 1346 error = process_section(name, ifl, shdr, scn, ndx, ident, ofl); 1347 if ((error == 0) || (error == S_ERROR)) 1348 return (error); 1349 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 */ 1355 isp = ifl->ifl_isdesc[ndx]; 1356 size = isp->is_indata->d_size; 1357 if (size) { 1358 data = isp->is_indata->d_buf; 1359 if (data[0] != '\0' || data[size - 1] != '\0') 1360 ld_eprintf(ofl, ERR_WARNING, 1361 MSG_INTL(MSG_FIL_MALSTR), ifl->ifl_name, 1362 EC_WORD(isp->is_scnndx), name); 1363 } else 1364 isp->is_indata->d_buf = (void *)MSG_ORIG(MSG_STR_EMPTY); 1365 1366 ifl->ifl_flags |= FLG_IF_HSTRTAB; 1367 return (1); 1368 } 1369 1370 /* 1371 * Invalid sections produce a warning and are skipped. 1372 */ 1373 static uintptr_t 1374 /* ARGSUSED3 */ 1375 invalid_section(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1376 Word ndx, int ident, Ofl_desc *ofl) 1377 { 1378 Conv_inv_buf_t inv_buf; 1379 1380 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_INVALSEC), 1381 ifl->ifl_name, EC_WORD(ndx), name, 1382 conv_sec_type(ifl->ifl_ehdr->e_ident[EI_OSABI], 1383 ifl->ifl_ehdr->e_machine, shdr->sh_type, 0, &inv_buf)); 1384 return (1); 1385 } 1386 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 */ 1401 inline static int 1402 is_name_cmp(const char *is_name, const char *match_name, size_t match_len) 1403 { 1404 /* 1405 * If the start of is_name is not a match for name, 1406 * the match fails. 1407 */ 1408 if (strncmp(is_name, match_name, match_len) != 0) 1409 return (0); 1410 1411 /* 1412 * The prefix matched. The next character must be either '%', or 1413 * NULL, in order for a match to be true. 1414 */ 1415 is_name += match_len; 1416 return ((*is_name == '\0') || (*is_name == '%')); 1417 } 1418 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*/ 1433 inline static Boolean 1434 process_progbits_alloc(const char *name, Ifl_desc *ifl, Shdr *shdr, 1435 Word ndx, int *ident, Ofl_desc *ofl, Boolean is_stab_index, 1436 Word *is_flags) 1437 { 1438 Boolean done = FALSE; 1439 1440 if (name[0] == '.') { 1441 switch (name[1]) { 1442 case 'e': 1443 if (!is_name_cmp(name, MSG_ORIG(MSG_SCN_EHFRAME), 1444 MSG_SCN_EHFRAME_SIZE)) 1445 break; 1446 1447 *ident = ld_targ.t_id.id_unwind; 1448 *is_flags |= FLG_IS_EHFRAME; 1449 done = TRUE; 1450 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 */ 1477 break; 1478 case 'g': 1479 if (is_name_cmp(name, MSG_ORIG(MSG_SCN_GOT), 1480 MSG_SCN_GOT_SIZE)) { 1481 *ident = ld_targ.t_id.id_null; 1482 done = TRUE; 1483 break; 1484 } 1485 if ((ld_targ.t_m.m_sht_unwind == SHT_PROGBITS) && 1486 is_name_cmp(name, MSG_ORIG(MSG_SCN_GCC_X_TBL), 1487 MSG_SCN_GCC_X_TBL_SIZE)) { 1488 *ident = ld_targ.t_id.id_unwind; 1489 done = TRUE; 1490 break; 1491 } 1492 break; 1493 case 'p': 1494 if (is_name_cmp(name, MSG_ORIG(MSG_SCN_PLT), 1495 MSG_SCN_PLT_SIZE)) { 1496 *ident = ld_targ.t_id.id_null; 1497 done = TRUE; 1498 } 1499 break; 1500 } 1501 } 1502 if (!done) { 1503 if (is_stab_index) { 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 */ 1515 *ident = ld_targ.t_id.id_interp; 1516 } else { 1517 *ident = ld_targ.t_id.id_data; 1518 } 1519 } 1520 1521 return (TRUE); 1522 } 1523 1524 /* 1525 * Process a progbits section. 1526 */ 1527 static uintptr_t 1528 process_progbits(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1529 Word ndx, int ident, Ofl_desc *ofl) 1530 { 1531 Boolean is_stab_index = FALSE; 1532 Word is_flags = 0; 1533 uintptr_t r; 1534 1535 /* 1536 * Never include .stab.excl sections in any output file. 1537 * If the -s flag has been specified strip any .stab sections. 1538 */ 1539 if (ident && (strncmp(name, MSG_ORIG(MSG_SCN_STAB), 1540 MSG_SCN_STAB_SIZE) == 0)) { 1541 if ((ofl->ofl_flags & FLG_OF_STRIP) || 1542 (strcmp((name + MSG_SCN_STAB_SIZE), 1543 MSG_ORIG(MSG_SCN_EXCL)) == 0)) 1544 return (1); 1545 1546 if (strcmp((name + MSG_SCN_STAB_SIZE), 1547 MSG_ORIG(MSG_SCN_INDEX)) == 0) 1548 is_stab_index = TRUE; 1549 } 1550 1551 if ((ofl->ofl_flags & FLG_OF_STRIP) && ident) { 1552 if ((strncmp(name, MSG_ORIG(MSG_SCN_DEBUG), 1553 MSG_SCN_DEBUG_SIZE) == 0) || 1554 (strcmp(name, MSG_ORIG(MSG_SCN_LINE)) == 0)) 1555 return (1); 1556 } 1557 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 */ 1570 if (ident) { 1571 if (shdr->sh_flags & SHF_TLS) { 1572 ident = ld_targ.t_id.id_tls; 1573 } else if ((shdr->sh_flags & ~ALL_SHF_IGNORE) == 1574 (SHF_ALLOC | SHF_EXECINSTR)) { 1575 ident = ld_targ.t_id.id_text; 1576 } else if (shdr->sh_flags & SHF_ALLOC) { 1577 if (process_progbits_alloc(name, ifl, shdr, ndx, 1578 &ident, ofl, is_stab_index, &is_flags) == FALSE) 1579 return (S_ERROR); 1580 } else { 1581 ident = ld_targ.t_id.id_note; 1582 } 1583 } 1584 1585 r = process_section(name, ifl, shdr, scn, ndx, ident, ofl); 1586 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 */ 1591 if ((is_flags != 0) && (r == 1)) 1592 ifl->ifl_isdesc[ndx]->is_flags |= is_flags; 1593 1594 return (r); 1595 } 1596 1597 /* 1598 * Handles the SHT_SUNW_{DEBUG,DEBUGSTR) sections. 1599 */ 1600 static uintptr_t 1601 process_debug(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1602 Word ndx, int ident, Ofl_desc *ofl) 1603 { 1604 /* 1605 * Debug information is discarded when the 'ld -s' flag is invoked. 1606 */ 1607 if (ofl->ofl_flags & FLG_OF_STRIP) { 1608 return (1); 1609 } 1610 return (process_progbits(name, ifl, shdr, scn, ndx, ident, ofl)); 1611 } 1612 1613 /* 1614 * Process a nobits section. 1615 */ 1616 static uintptr_t 1617 process_nobits(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1618 Word ndx, int ident, Ofl_desc *ofl) 1619 { 1620 if (ident) { 1621 if (shdr->sh_flags & SHF_TLS) 1622 ident = ld_targ.t_id.id_tlsbss; 1623 #if defined(_ELF64) 1624 else if ((shdr->sh_flags & SHF_AMD64_LARGE) && 1625 (ld_targ.t_m.m_mach == EM_AMD64)) 1626 ident = ld_targ.t_id.id_lbss; 1627 #endif 1628 else 1629 ident = ld_targ.t_id.id_bss; 1630 } 1631 return (process_section(name, ifl, shdr, scn, ndx, ident, ofl)); 1632 } 1633 1634 /* 1635 * Process a SHT_*_ARRAY section. 1636 */ 1637 static uintptr_t 1638 process_array(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1639 Word ndx, int ident, Ofl_desc *ofl) 1640 { 1641 uintptr_t error; 1642 1643 if (ident) 1644 ident = ld_targ.t_id.id_array; 1645 1646 error = process_section(name, ifl, shdr, scn, ndx, ident, ofl); 1647 if ((error == 0) || (error == S_ERROR)) 1648 return (error); 1649 1650 return (1); 1651 } 1652 1653 static uintptr_t 1654 /* ARGSUSED1 */ 1655 array_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl) 1656 { 1657 Os_desc *osp; 1658 Shdr *shdr; 1659 1660 if ((isc == NULL) || ((osp = isc->is_osdesc) == NULL)) 1661 return (0); 1662 1663 shdr = isc->is_shdr; 1664 1665 if ((shdr->sh_type == SHT_FINI_ARRAY) && 1666 (ofl->ofl_osfiniarray == NULL)) 1667 ofl->ofl_osfiniarray = osp; 1668 else if ((shdr->sh_type == SHT_INIT_ARRAY) && 1669 (ofl->ofl_osinitarray == NULL)) 1670 ofl->ofl_osinitarray = osp; 1671 else if ((shdr->sh_type == SHT_PREINIT_ARRAY) && 1672 (ofl->ofl_ospreinitarray == NULL)) 1673 ofl->ofl_ospreinitarray = osp; 1674 1675 return (1); 1676 } 1677 1678 /* 1679 * Process a SHT_SYMTAB_SHNDX section. 1680 */ 1681 static uintptr_t 1682 process_sym_shndx(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1683 Word ndx, int ident, Ofl_desc *ofl) 1684 { 1685 if (process_input(name, ifl, shdr, scn, ndx, ident, ofl) == S_ERROR) 1686 return (S_ERROR); 1687 1688 /* 1689 * Have we already seen the related SYMTAB - if so verify it now. 1690 */ 1691 if (shdr->sh_link < ndx) { 1692 Is_desc *isp = ifl->ifl_isdesc[shdr->sh_link]; 1693 1694 if ((isp == NULL) || ((isp->is_shdr->sh_type != SHT_SYMTAB) && 1695 (isp->is_shdr->sh_type != SHT_DYNSYM))) { 1696 ld_eprintf(ofl, ERR_FATAL, 1697 MSG_INTL(MSG_FIL_INVSHLINK), ifl->ifl_name, 1698 EC_WORD(ndx), name, EC_XWORD(shdr->sh_link)); 1699 return (S_ERROR); 1700 } 1701 isp->is_symshndx = ifl->ifl_isdesc[ndx]; 1702 } 1703 return (1); 1704 } 1705 1706 /* 1707 * Final processing for SHT_SYMTAB_SHNDX section. 1708 */ 1709 static uintptr_t 1710 /* ARGSUSED2 */ 1711 sym_shndx_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl) 1712 { 1713 if (isc->is_shdr->sh_link > isc->is_scnndx) { 1714 Is_desc *isp = ifl->ifl_isdesc[isc->is_shdr->sh_link]; 1715 1716 if ((isp == NULL) || ((isp->is_shdr->sh_type != SHT_SYMTAB) && 1717 (isp->is_shdr->sh_type != SHT_DYNSYM))) { 1718 ld_eprintf(ofl, ERR_FATAL, 1719 MSG_INTL(MSG_FIL_INVSHLINK), isc->is_file->ifl_name, 1720 EC_WORD(isc->is_scnndx), isc->is_name, 1721 EC_XWORD(isc->is_shdr->sh_link)); 1722 return (S_ERROR); 1723 } 1724 isp->is_symshndx = isc; 1725 } 1726 return (1); 1727 } 1728 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 1738 process_rel_dynamic(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1739 Word ndx, int ident, Ofl_desc *ofl) 1740 { 1741 Dyn *dyn; 1742 Elf_Scn *strscn; 1743 Elf_Data *dp; 1744 char *str; 1745 1746 /* 1747 * Process .dynamic sections from relocatable objects ? 1748 */ 1749 if ((ofl->ofl_flags1 & FLG_OF1_RELDYN) == 0) 1750 return (1); 1751 1752 /* 1753 * Find the string section associated with the .dynamic section. 1754 */ 1755 if ((strscn = elf_getscn(ifl->ifl_elf, shdr->sh_link)) == NULL) { 1756 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSCN), 1757 ifl->ifl_name); 1758 return (0); 1759 } 1760 dp = elf_getdata(strscn, NULL); 1761 str = (char *)dp->d_buf; 1762 1763 /* 1764 * And get the .dynamic data 1765 */ 1766 dp = elf_getdata(scn, NULL); 1767 1768 for (dyn = (Dyn *)dp->d_buf; dyn->d_tag != DT_NULL; dyn++) { 1769 Ifl_desc *difl; 1770 1771 switch (dyn->d_tag) { 1772 case DT_NEEDED: 1773 case DT_USED: 1774 if (((difl = libld_calloc(1, 1775 sizeof (Ifl_desc))) == NULL) || 1776 (aplist_append(&ofl->ofl_sos, difl, 1777 AL_CNT_OFL_LIBS) == NULL)) 1778 return (S_ERROR); 1779 1780 difl->ifl_name = MSG_ORIG(MSG_STR_DYNAMIC); 1781 difl->ifl_soname = str + (size_t)dyn->d_un.d_val; 1782 difl->ifl_flags = FLG_IF_NEEDSTR; 1783 break; 1784 case DT_RPATH: 1785 case DT_RUNPATH: 1786 if ((ofl->ofl_rpath = add_string(ofl->ofl_rpath, 1787 (str + (size_t)dyn->d_un.d_val))) == 1788 (const char *)S_ERROR) 1789 return (S_ERROR); 1790 break; 1791 case DT_VERSYM: 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 */ 1798 ifl->ifl_flags |= FLG_IF_GNUVER; 1799 break; 1800 } 1801 } 1802 return (1); 1803 } 1804 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 */ 1819 static char *machine = NULL; 1820 static size_t machine_sz = 0; 1821 static char *platform = NULL; 1822 static size_t platform_sz = 0; 1823 static Isa_desc *isa = NULL; 1824 static Uts_desc *uts = NULL; 1825 1826 static char * 1827 expand(const char *parent, const char *name, char **next) 1828 { 1829 char _name[PATH_MAX], *nptr, *_next; 1830 const char *optr; 1831 size_t nrem = PATH_MAX - 1; 1832 int expanded = 0, _expanded, isaflag = 0; 1833 1834 optr = name; 1835 nptr = _name; 1836 1837 while (*optr) { 1838 if (nrem == 0) 1839 return ((char *)name); 1840 1841 if (*optr != '$') { 1842 *nptr++ = *optr++, nrem--; 1843 continue; 1844 } 1845 1846 _expanded = 0; 1847 1848 if (strncmp(optr, MSG_ORIG(MSG_STR_ORIGIN), 1849 MSG_STR_ORIGIN_SIZE) == 0) { 1850 char *eptr; 1851 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 */ 1859 if ((eptr = strrchr(parent, '/')) == NULL) { 1860 *nptr++ = '.'; 1861 nrem--; 1862 } else { 1863 size_t len = eptr - parent; 1864 1865 if (len >= nrem) 1866 return ((char *)name); 1867 1868 (void) strncpy(nptr, parent, len); 1869 nptr = nptr + len; 1870 nrem -= len; 1871 } 1872 optr += MSG_STR_ORIGIN_SIZE; 1873 expanded = _expanded = 1; 1874 1875 } else if (strncmp(optr, MSG_ORIG(MSG_STR_MACHINE), 1876 MSG_STR_MACHINE_SIZE) == 0) { 1877 /* 1878 * Establish the machine from sysconf - like uname -i. 1879 */ 1880 if ((machine == NULL) && (machine_sz == 0)) { 1881 char info[SYS_NMLN]; 1882 long size; 1883 1884 size = sysinfo(SI_MACHINE, info, SYS_NMLN); 1885 if ((size != -1) && 1886 (machine = libld_malloc((size_t)size))) { 1887 (void) strcpy(machine, info); 1888 machine_sz = (size_t)size - 1; 1889 } else 1890 machine_sz = 1; 1891 } 1892 if (machine) { 1893 if (machine_sz >= nrem) 1894 return ((char *)name); 1895 1896 (void) strncpy(nptr, machine, machine_sz); 1897 nptr = nptr + machine_sz; 1898 nrem -= machine_sz; 1899 1900 optr += MSG_STR_MACHINE_SIZE; 1901 expanded = _expanded = 1; 1902 } 1903 1904 } else if (strncmp(optr, MSG_ORIG(MSG_STR_PLATFORM), 1905 MSG_STR_PLATFORM_SIZE) == 0) { 1906 /* 1907 * Establish the platform from sysconf - like uname -i. 1908 */ 1909 if ((platform == NULL) && (platform_sz == 0)) { 1910 char info[SYS_NMLN]; 1911 long size; 1912 1913 size = sysinfo(SI_PLATFORM, info, SYS_NMLN); 1914 if ((size != -1) && 1915 (platform = libld_malloc((size_t)size))) { 1916 (void) strcpy(platform, info); 1917 platform_sz = (size_t)size - 1; 1918 } else 1919 platform_sz = 1; 1920 } 1921 if (platform) { 1922 if (platform_sz >= nrem) 1923 return ((char *)name); 1924 1925 (void) strncpy(nptr, platform, platform_sz); 1926 nptr = nptr + platform_sz; 1927 nrem -= platform_sz; 1928 1929 optr += MSG_STR_PLATFORM_SIZE; 1930 expanded = _expanded = 1; 1931 } 1932 1933 } else if (strncmp(optr, MSG_ORIG(MSG_STR_OSNAME), 1934 MSG_STR_OSNAME_SIZE) == 0) { 1935 /* 1936 * Establish the os name - like uname -s. 1937 */ 1938 if (uts == NULL) 1939 uts = conv_uts(); 1940 1941 if (uts && uts->uts_osnamesz) { 1942 if (uts->uts_osnamesz >= nrem) 1943 return ((char *)name); 1944 1945 (void) strncpy(nptr, uts->uts_osname, 1946 uts->uts_osnamesz); 1947 nptr = nptr + uts->uts_osnamesz; 1948 nrem -= uts->uts_osnamesz; 1949 1950 optr += MSG_STR_OSNAME_SIZE; 1951 expanded = _expanded = 1; 1952 } 1953 1954 } else if (strncmp(optr, MSG_ORIG(MSG_STR_OSREL), 1955 MSG_STR_OSREL_SIZE) == 0) { 1956 /* 1957 * Establish the os release - like uname -r. 1958 */ 1959 if (uts == NULL) 1960 uts = conv_uts(); 1961 1962 if (uts && uts->uts_osrelsz) { 1963 if (uts->uts_osrelsz >= nrem) 1964 return ((char *)name); 1965 1966 (void) strncpy(nptr, uts->uts_osrel, 1967 uts->uts_osrelsz); 1968 nptr = nptr + uts->uts_osrelsz; 1969 nrem -= uts->uts_osrelsz; 1970 1971 optr += MSG_STR_OSREL_SIZE; 1972 expanded = _expanded = 1; 1973 } 1974 1975 } else if ((strncmp(optr, MSG_ORIG(MSG_STR_ISALIST), 1976 MSG_STR_ISALIST_SIZE) == 0) && next && (isaflag++ == 0)) { 1977 /* 1978 * Establish instruction sets from sysconf. Note that 1979 * this is only meaningful from runpaths. 1980 */ 1981 if (isa == NULL) 1982 isa = conv_isalist(); 1983 1984 if (isa && isa->isa_listsz && 1985 (nrem > isa->isa_opt->isa_namesz)) { 1986 size_t mlen, tlen, hlen = optr - name; 1987 size_t no; 1988 char *lptr; 1989 Isa_opt *opt = isa->isa_opt; 1990 1991 (void) strncpy(nptr, opt->isa_name, 1992 opt->isa_namesz); 1993 nptr = nptr + opt->isa_namesz; 1994 nrem -= opt->isa_namesz; 1995 1996 optr += MSG_STR_ISALIST_SIZE; 1997 expanded = _expanded = 1; 1998 1999 tlen = strlen(optr); 2000 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 */ 2008 mlen = ((hlen + tlen) * (isa->isa_optno - 1)) + 2009 isa->isa_listsz - opt->isa_namesz; 2010 if (*next) 2011 mlen += strlen(*next); 2012 if ((_next = lptr = libld_malloc(mlen)) == NULL) 2013 return (0); 2014 2015 for (no = 1, opt++; no < isa->isa_optno; 2016 no++, opt++) { 2017 (void) strncpy(lptr, name, hlen); 2018 lptr = lptr + hlen; 2019 (void) strncpy(lptr, opt->isa_name, 2020 opt->isa_namesz); 2021 lptr = lptr + opt->isa_namesz; 2022 (void) strncpy(lptr, optr, tlen); 2023 lptr = lptr + tlen; 2024 *lptr++ = ':'; 2025 } 2026 if (*next) 2027 (void) strcpy(lptr, *next); 2028 else 2029 *--lptr = '\0'; 2030 } 2031 } 2032 2033 /* 2034 * If no expansion occurred skip the $ and continue. 2035 */ 2036 if (_expanded == 0) 2037 *nptr++ = *optr++, nrem--; 2038 } 2039 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 */ 2052 if (isaflag) { 2053 if (isaflag == 1) 2054 *next = _next; 2055 else 2056 return ((char *)name); 2057 } 2058 2059 *nptr = '\0'; 2060 2061 if (expanded) { 2062 if ((nptr = libld_malloc(strlen(_name) + 1)) == NULL) 2063 return ((char *)name); 2064 (void) strcpy(nptr, _name); 2065 return (nptr); 2066 } 2067 return ((char *)name); 2068 } 2069 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 2081 process_dynamic_isgnu(const char *name, Ifl_desc *ifl, Shdr *shdr, 2082 Elf_Scn *scn, Word ndx, int ident, Ofl_desc *ofl) 2083 { 2084 Dyn *dyn; 2085 Elf_Data *dp; 2086 uintptr_t error; 2087 2088 error = process_section(name, ifl, shdr, scn, ndx, ident, ofl); 2089 if ((error == 0) || (error == S_ERROR)) 2090 return (error); 2091 2092 /* Get the .dynamic data */ 2093 dp = elf_getdata(scn, NULL); 2094 2095 for (dyn = (Dyn *)dp->d_buf; dyn->d_tag != DT_NULL; dyn++) { 2096 if (dyn->d_tag == DT_VERSYM) { 2097 ifl->ifl_flags |= FLG_IF_GNUVER; 2098 break; 2099 } 2100 } 2101 return (1); 2102 } 2103 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 2117 process_dynamic(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl) 2118 { 2119 Dyn *data, *dyn; 2120 char *str, *rpath = NULL; 2121 const char *soname, *needed; 2122 Boolean no_undef; 2123 2124 data = (Dyn *)isc->is_indata->d_buf; 2125 str = (char *)ifl->ifl_isdesc[isc->is_shdr->sh_link]->is_indata->d_buf; 2126 2127 /* Determine if we need to examine the runpaths and NEEDED entries */ 2128 no_undef = (ofl->ofl_flags & (FLG_OF_NOUNDEF | FLG_OF_SYMBOLIC)) || 2129 OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS); 2130 2131 /* 2132 * First loop through the dynamic section looking for a run path. 2133 */ 2134 if (no_undef) { 2135 for (dyn = data; dyn->d_tag != DT_NULL; dyn++) { 2136 if ((dyn->d_tag != DT_RPATH) && 2137 (dyn->d_tag != DT_RUNPATH)) 2138 continue; 2139 if ((rpath = str + (size_t)dyn->d_un.d_val) == NULL) 2140 continue; 2141 break; 2142 } 2143 } 2144 2145 /* 2146 * Now look for any needed dependencies (which may use the rpath) 2147 * or a new SONAME. 2148 */ 2149 for (dyn = data; dyn->d_tag != DT_NULL; dyn++) { 2150 if (dyn->d_tag == DT_SONAME) { 2151 if ((soname = str + (size_t)dyn->d_un.d_val) == NULL) 2152 continue; 2153 2154 /* 2155 * Update the input file structure with this new name. 2156 */ 2157 ifl->ifl_soname = soname; 2158 2159 } else if ((dyn->d_tag == DT_NEEDED) || 2160 (dyn->d_tag == DT_USED)) { 2161 Sdf_desc *sdf; 2162 2163 if (!no_undef) 2164 continue; 2165 if ((needed = str + (size_t)dyn->d_un.d_val) == NULL) 2166 continue; 2167 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 */ 2173 needed = expand(ifl->ifl_name, needed, NULL); 2174 2175 if ((sdf = sdf_find(needed, ofl->ofl_soneed)) == NULL) { 2176 if ((sdf = sdf_add(needed, 2177 &ofl->ofl_soneed)) == (Sdf_desc *)S_ERROR) 2178 return (S_ERROR); 2179 sdf->sdf_rfile = ifl->ifl_name; 2180 } 2181 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 */ 2187 if (rpath && (sdf->sdf_rpath == NULL)) 2188 sdf->sdf_rpath = rpath; 2189 2190 } else if (dyn->d_tag == DT_FLAGS_1) { 2191 if (dyn->d_un.d_val & (DF_1_INITFIRST | DF_1_INTERPOSE)) 2192 ifl->ifl_flags &= ~FLG_IF_LAZYLD; 2193 if (dyn->d_un.d_val & DF_1_DISPRELPND) 2194 ifl->ifl_flags |= FLG_IF_DISPPEND; 2195 if (dyn->d_un.d_val & DF_1_DISPRELDNE) 2196 ifl->ifl_flags |= FLG_IF_DISPDONE; 2197 if (dyn->d_un.d_val & DF_1_NODIRECT) 2198 ifl->ifl_flags |= FLG_IF_NODIRECT; 2199 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 */ 2212 if ((dyn->d_un.d_val & DF_1_INTERPOSE) && 2213 (ofl->ofl_flags & FLG_OF_EXEC)) 2214 ifl->ifl_flags |= FLG_IF_DEPREQD; 2215 2216 } else if ((dyn->d_tag == DT_AUDIT) && 2217 (ifl->ifl_flags & FLG_IF_NEEDED)) { 2218 /* 2219 * Record audit string as DT_DEPAUDIT. 2220 */ 2221 if ((ofl->ofl_depaudit = add_string(ofl->ofl_depaudit, 2222 (str + (size_t)dyn->d_un.d_val))) == 2223 (const char *)S_ERROR) 2224 return (S_ERROR); 2225 2226 } else if (dyn->d_tag == DT_SUNW_RTLDINF) { 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 */ 2235 ifl->ifl_flags &= ~MSK_IF_POSFLAG1; 2236 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 */ 2243 ifl->ifl_flags |= FLG_IF_RTLDINF; 2244 } 2245 } 2246 2247 /* 2248 * Perform some SONAME sanity checks. 2249 */ 2250 if (ifl->ifl_flags & FLG_IF_NEEDED) { 2251 Ifl_desc *sifl; 2252 Aliste idx; 2253 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 */ 2262 for (APLIST_TRAVERSE(ofl->ofl_sos, idx, sifl)) { 2263 if ((strcmp(ifl->ifl_soname, sifl->ifl_soname) == 0) && 2264 (ifl != sifl)) { 2265 const char *hint, *iflb, *siflb; 2266 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 */ 2274 iflb = strrchr(ifl->ifl_name, '/'); 2275 if (iflb == NULL) 2276 iflb = ifl->ifl_name; 2277 else 2278 iflb++; 2279 2280 siflb = strrchr(sifl->ifl_name, '/'); 2281 if (siflb == NULL) 2282 siflb = sifl->ifl_name; 2283 else 2284 siflb++; 2285 2286 if (strcmp(iflb, siflb) == 0) 2287 hint = MSG_INTL(MSG_REC_CNFLTHINT); 2288 else 2289 hint = MSG_ORIG(MSG_STR_EMPTY); 2290 2291 ld_eprintf(ofl, ERR_FATAL, 2292 MSG_INTL(MSG_REC_OBJCNFLT), sifl->ifl_name, 2293 ifl->ifl_name, sifl->ifl_soname, hint); 2294 return (0); 2295 } 2296 } 2297 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 */ 2303 if (ofl->ofl_soname && 2304 (strcmp(ofl->ofl_soname, ifl->ifl_soname) == 0)) { 2305 ld_eprintf(ofl, ERR_FATAL, 2306 MSG_INTL(MSG_REC_OPTCNFLT), ifl->ifl_name, 2307 MSG_INTL(MSG_MARG_SONAME), ifl->ifl_soname); 2308 return (0); 2309 } 2310 } 2311 return (1); 2312 } 2313 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 2320 process_progbits_final(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl) 2321 { 2322 if (isc->is_osdesc && (isc->is_flags & FLG_IS_EHFRAME) && 2323 (ld_unwind_register(isc->is_osdesc, ofl) == S_ERROR)) 2324 return (S_ERROR); 2325 2326 return (1); 2327 } 2328 2329 /* 2330 * Process a group section. 2331 */ 2332 static uintptr_t 2333 process_group(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 2334 Word ndx, int ident, Ofl_desc *ofl) 2335 { 2336 uintptr_t error; 2337 2338 error = process_section(name, ifl, shdr, scn, ndx, ident, ofl); 2339 if ((error == 0) || (error == S_ERROR)) 2340 return (error); 2341 2342 /* 2343 * Indicate that this input file has groups to process. Groups are 2344 * processed after all input sections have been processed. 2345 */ 2346 ifl->ifl_flags |= FLG_IF_GROUPS; 2347 2348 return (1); 2349 } 2350 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 2357 rel_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl) 2358 { 2359 Word rndx; 2360 Is_desc *risc; 2361 Os_desc *osp; 2362 Shdr *shdr = isc->is_shdr; 2363 Conv_inv_buf_t inv_buf; 2364 2365 /* 2366 * Make sure this is a valid relocation we can handle. 2367 */ 2368 if (shdr->sh_type != ld_targ.t_m.m_rel_sht_type) { 2369 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVALSEC), 2370 ifl->ifl_name, EC_WORD(isc->is_scnndx), isc->is_name, 2371 conv_sec_type(ifl->ifl_ehdr->e_ident[EI_OSABI], 2372 ifl->ifl_ehdr->e_machine, shdr->sh_type, 0, &inv_buf)); 2373 return (0); 2374 } 2375 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 */ 2383 rndx = shdr->sh_info; 2384 if (rndx >= ifl->ifl_shnum) { 2385 /* 2386 * Broken input file. 2387 */ 2388 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO), 2389 ifl->ifl_name, EC_WORD(isc->is_scnndx), isc->is_name, 2390 EC_XWORD(rndx)); 2391 return (0); 2392 } 2393 if (rndx == 0) { 2394 if (aplist_append(&ofl->ofl_extrarels, isc, 2395 AL_CNT_OFL_RELS) == NULL) 2396 return (S_ERROR); 2397 2398 } else if ((risc = ifl->ifl_isdesc[rndx]) != NULL) { 2399 /* 2400 * Discard relocations if they are against a section 2401 * which has been discarded. 2402 */ 2403 if (risc->is_flags & FLG_IS_DISCARD) 2404 return (1); 2405 2406 if ((osp = risc->is_osdesc) == NULL) { 2407 if (risc->is_shdr->sh_type == SHT_SUNW_move) { 2408 /* 2409 * This section is processed later in 2410 * process_movereloc(). 2411 */ 2412 if (aplist_append(&ofl->ofl_ismoverel, 2413 isc, AL_CNT_OFL_MOVE) == NULL) 2414 return (S_ERROR); 2415 return (1); 2416 } 2417 ld_eprintf(ofl, ERR_FATAL, 2418 MSG_INTL(MSG_FIL_INVRELOC1), ifl->ifl_name, 2419 EC_WORD(isc->is_scnndx), isc->is_name, 2420 EC_WORD(risc->is_scnndx), risc->is_name); 2421 return (0); 2422 } 2423 if (aplist_append(&osp->os_relisdescs, isc, 2424 AL_CNT_OS_RELISDESCS) == NULL) 2425 return (S_ERROR); 2426 } 2427 return (1); 2428 } 2429 2430 /* 2431 * SHF_EXCLUDE flags is set for this section. 2432 */ 2433 static uintptr_t 2434 process_exclude(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 2435 Word ndx, Ofl_desc *ofl) 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 */ 2443 if (shdr->sh_type == SHT_SYMTAB || shdr->sh_type == SHT_DYNSYM) 2444 return (0); 2445 2446 /* 2447 * Other checks 2448 */ 2449 if (shdr->sh_flags & SHF_ALLOC) { 2450 /* 2451 * A conflict, issue an warning message, and ignore the section. 2452 */ 2453 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_EXCLUDE), 2454 ifl->ifl_name, EC_WORD(ndx), name); 2455 return (0); 2456 } 2457 2458 /* 2459 * This sections is not going to the output file. 2460 */ 2461 return (process_section(name, ifl, shdr, scn, ndx, 0, ofl)); 2462 } 2463 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 */ 2470 typedef uintptr_t (* initial_func_t)(const char *, Ifl_desc *, Shdr *, 2471 Elf_Scn *, Word, int, Ofl_desc *); 2472 2473 static initial_func_t Initial[SHT_NUM][2] = { 2474 /* ET_REL ET_DYN */ 2475 2476 /* SHT_NULL */ invalid_section, invalid_section, 2477 /* SHT_PROGBITS */ process_progbits, process_progbits, 2478 /* SHT_SYMTAB */ process_input, process_input, 2479 /* SHT_STRTAB */ process_strtab, process_strtab, 2480 /* SHT_RELA */ process_reloc, process_reloc, 2481 /* SHT_HASH */ invalid_section, NULL, 2482 /* SHT_DYNAMIC */ process_rel_dynamic, process_dynamic_isgnu, 2483 /* SHT_NOTE */ process_section, NULL, 2484 /* SHT_NOBITS */ process_nobits, process_nobits, 2485 /* SHT_REL */ process_reloc, process_reloc, 2486 /* SHT_SHLIB */ process_section, invalid_section, 2487 /* SHT_DYNSYM */ invalid_section, process_input, 2488 /* SHT_UNKNOWN12 */ process_progbits, process_progbits, 2489 /* SHT_UNKNOWN13 */ process_progbits, process_progbits, 2490 /* SHT_INIT_ARRAY */ process_array, NULL, 2491 /* SHT_FINI_ARRAY */ process_array, NULL, 2492 /* SHT_PREINIT_ARRAY */ process_array, NULL, 2493 /* SHT_GROUP */ process_group, invalid_section, 2494 /* SHT_SYMTAB_SHNDX */ process_sym_shndx, NULL 2495 }; 2496 2497 typedef uintptr_t (* final_func_t)(Is_desc *, Ifl_desc *, Ofl_desc *); 2498 2499 static final_func_t Final[SHT_NUM][2] = { 2500 /* ET_REL ET_DYN */ 2501 2502 /* SHT_NULL */ NULL, NULL, 2503 /* SHT_PROGBITS */ process_progbits_final, NULL, 2504 /* SHT_SYMTAB */ ld_sym_process, ld_sym_process, 2505 /* SHT_STRTAB */ NULL, NULL, 2506 /* SHT_RELA */ rel_process, NULL, 2507 /* SHT_HASH */ NULL, NULL, 2508 /* SHT_DYNAMIC */ NULL, process_dynamic, 2509 /* SHT_NOTE */ NULL, NULL, 2510 /* SHT_NOBITS */ NULL, NULL, 2511 /* SHT_REL */ rel_process, NULL, 2512 /* SHT_SHLIB */ NULL, NULL, 2513 /* SHT_DYNSYM */ NULL, ld_sym_process, 2514 /* SHT_UNKNOWN12 */ NULL, NULL, 2515 /* SHT_UNKNOWN13 */ NULL, NULL, 2516 /* SHT_INIT_ARRAY */ array_process, NULL, 2517 /* SHT_FINI_ARRAY */ array_process, NULL, 2518 /* SHT_PREINIT_ARRAY */ array_process, NULL, 2519 /* SHT_GROUP */ NULL, NULL, 2520 /* SHT_SYMTAB_SHNDX */ sym_shndx_process, NULL 2521 }; 2522 2523 #define MAXNDXSIZE 10 2524 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 2531 process_elf(Ifl_desc *ifl, Elf *elf, Ofl_desc *ofl) 2532 { 2533 Elf_Scn *scn; 2534 Shdr *shdr; 2535 Word ndx, sndx, ordndx = 0, ordcnt = 0; 2536 char *str, *name; 2537 Word row, column; 2538 int ident; 2539 uintptr_t error; 2540 Is_desc *vdfisp, *vndisp, *vsyisp, *sifisp; 2541 Is_desc *capinfoisp, *capisp; 2542 Sdf_desc *sdf; 2543 Place_path_info path_info_buf, *path_info; 2544 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 */ 2550 path_info = ld_place_path_info_init(ofl, ifl, &path_info_buf); 2551 2552 /* 2553 * First process the .shstrtab section so that later sections can 2554 * reference their name. 2555 */ 2556 ld_sup_file(ofl, ifl->ifl_name, elf_kind(elf), ifl->ifl_flags, elf); 2557 2558 sndx = ifl->ifl_shstrndx; 2559 if ((scn = elf_getscn(elf, (size_t)sndx)) == NULL) { 2560 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSCN), 2561 ifl->ifl_name); 2562 return (0); 2563 } 2564 if ((shdr = elf_getshdr(scn)) == NULL) { 2565 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR), 2566 ifl->ifl_name); 2567 return (0); 2568 } 2569 if ((name = elf_strptr(elf, (size_t)sndx, (size_t)shdr->sh_name)) == 2570 NULL) { 2571 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_STRPTR), 2572 ifl->ifl_name); 2573 return (0); 2574 } 2575 2576 if (ld_sup_input_section(ofl, ifl, name, &shdr, sndx, scn, 2577 elf) == S_ERROR) 2578 return (S_ERROR); 2579 2580 /* 2581 * Reset the name since the shdr->sh_name could have been changed as 2582 * part of ld_sup_input_section(). 2583 */ 2584 if ((name = elf_strptr(elf, (size_t)sndx, (size_t)shdr->sh_name)) == 2585 NULL) { 2586 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_STRPTR), 2587 ifl->ifl_name); 2588 return (0); 2589 } 2590 2591 error = process_strtab(name, ifl, shdr, scn, sndx, FALSE, ofl); 2592 if ((error == 0) || (error == S_ERROR)) 2593 return (error); 2594 str = ifl->ifl_isdesc[sndx]->is_indata->d_buf; 2595 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 */ 2600 if (ifl->ifl_ehdr->e_type == ET_DYN) { 2601 column = 1; 2602 ofl->ofl_soscnt++; 2603 ident = ld_targ.t_id.id_null; 2604 } else { 2605 column = 0; 2606 ofl->ofl_objscnt++; 2607 ident = ld_targ.t_id.id_unknown; 2608 } 2609 2610 DBG_CALL(Dbg_file_generic(ofl->ofl_lml, ifl)); 2611 ndx = 0; 2612 vdfisp = vndisp = vsyisp = sifisp = capinfoisp = capisp = NULL; 2613 scn = NULL; 2614 while (scn = elf_nextscn(elf, scn)) { 2615 ndx++; 2616 2617 /* 2618 * As we've already processed the .shstrtab don't do it again. 2619 */ 2620 if (ndx == sndx) 2621 continue; 2622 2623 if ((shdr = elf_getshdr(scn)) == NULL) { 2624 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR), 2625 ifl->ifl_name); 2626 return (0); 2627 } 2628 name = str + (size_t)(shdr->sh_name); 2629 2630 if (ld_sup_input_section(ofl, ifl, name, &shdr, ndx, scn, 2631 elf) == S_ERROR) 2632 return (S_ERROR); 2633 2634 /* 2635 * Reset the name since the shdr->sh_name could have been 2636 * changed as part of ld_sup_input_section(). 2637 */ 2638 name = str + (size_t)(shdr->sh_name); 2639 2640 row = shdr->sh_type; 2641 2642 /* 2643 * If the section has the SHF_EXCLUDE flag on, and we're not 2644 * generating a relocatable object, exclude the section. 2645 */ 2646 if (((shdr->sh_flags & SHF_EXCLUDE) != 0) && 2647 ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) { 2648 if ((error = process_exclude(name, ifl, shdr, scn, 2649 ndx, ofl)) == S_ERROR) 2650 return (S_ERROR); 2651 if (error == 1) 2652 continue; 2653 } 2654 2655 /* 2656 * If this is a standard section type process it via the 2657 * appropriate action routine. 2658 */ 2659 if (row < SHT_NUM) { 2660 if (Initial[row][column] != NULL) { 2661 if (Initial[row][column](name, ifl, shdr, scn, 2662 ndx, ident, ofl) == S_ERROR) 2663 return (S_ERROR); 2664 } 2665 } else { 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 */ 2671 if (row < (Word)SHT_LOSUNW) { 2672 Conv_inv_buf_t inv_buf; 2673 2674 ld_eprintf(ofl, ERR_WARNING, 2675 MSG_INTL(MSG_FIL_INVALSEC), ifl->ifl_name, 2676 EC_WORD(ndx), name, conv_sec_type( 2677 ifl->ifl_ehdr->e_ident[EI_OSABI], 2678 ifl->ifl_ehdr->e_machine, 2679 shdr->sh_type, 0, &inv_buf)); 2680 } 2681 2682 /* 2683 * Handle sections greater than SHT_LOSUNW. 2684 */ 2685 switch (row) { 2686 case SHT_SUNW_dof: 2687 if (process_section(name, ifl, shdr, scn, 2688 ndx, ident, ofl) == S_ERROR) 2689 return (S_ERROR); 2690 break; 2691 case SHT_SUNW_cap: 2692 if (process_section(name, ifl, shdr, scn, ndx, 2693 ld_targ.t_id.id_null, ofl) == S_ERROR) 2694 return (S_ERROR); 2695 capisp = ifl->ifl_isdesc[ndx]; 2696 break; 2697 case SHT_SUNW_capinfo: 2698 if (process_section(name, ifl, shdr, scn, ndx, 2699 ld_targ.t_id.id_null, ofl) == S_ERROR) 2700 return (S_ERROR); 2701 capinfoisp = ifl->ifl_isdesc[ndx]; 2702 break; 2703 case SHT_SUNW_DEBUGSTR: 2704 case SHT_SUNW_DEBUG: 2705 if (process_debug(name, ifl, shdr, scn, 2706 ndx, ident, ofl) == S_ERROR) 2707 return (S_ERROR); 2708 break; 2709 case SHT_SUNW_move: 2710 if (process_section(name, ifl, shdr, scn, ndx, 2711 ld_targ.t_id.id_null, ofl) == S_ERROR) 2712 return (S_ERROR); 2713 break; 2714 case SHT_SUNW_syminfo: 2715 if (process_section(name, ifl, shdr, scn, ndx, 2716 ld_targ.t_id.id_null, ofl) == S_ERROR) 2717 return (S_ERROR); 2718 sifisp = ifl->ifl_isdesc[ndx]; 2719 break; 2720 case SHT_SUNW_ANNOTATE: 2721 if (process_progbits(name, ifl, shdr, scn, 2722 ndx, ident, ofl) == S_ERROR) 2723 return (S_ERROR); 2724 break; 2725 case SHT_SUNW_COMDAT: 2726 if (process_progbits(name, ifl, shdr, scn, 2727 ndx, ident, ofl) == S_ERROR) 2728 return (S_ERROR); 2729 ifl->ifl_isdesc[ndx]->is_flags |= FLG_IS_COMDAT; 2730 break; 2731 case SHT_SUNW_verdef: 2732 if (process_section(name, ifl, shdr, scn, ndx, 2733 ld_targ.t_id.id_null, ofl) == S_ERROR) 2734 return (S_ERROR); 2735 vdfisp = ifl->ifl_isdesc[ndx]; 2736 break; 2737 case SHT_SUNW_verneed: 2738 if (process_section(name, ifl, shdr, scn, ndx, 2739 ld_targ.t_id.id_null, ofl) == S_ERROR) 2740 return (S_ERROR); 2741 vndisp = ifl->ifl_isdesc[ndx]; 2742 break; 2743 case SHT_SUNW_versym: 2744 if (process_section(name, ifl, shdr, scn, ndx, 2745 ld_targ.t_id.id_null, ofl) == S_ERROR) 2746 return (S_ERROR); 2747 vsyisp = ifl->ifl_isdesc[ndx]; 2748 break; 2749 case SHT_SPARC_GOTDATA: 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 */ 2756 if (ld_targ.t_m.m_mach != 2757 LD_TARG_BYCLASS(EM_SPARC, EM_SPARCV9)) 2758 goto do_default; 2759 if (process_section(name, ifl, shdr, scn, ndx, 2760 ld_targ.t_id.id_gotdata, ofl) == S_ERROR) 2761 return (S_ERROR); 2762 break; 2763 #if defined(_ELF64) 2764 case SHT_AMD64_UNWIND: 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 */ 2771 if (ld_targ.t_m.m_mach != EM_AMD64) 2772 goto do_default; 2773 2774 /* 2775 * Target is x86, so this really is 2776 * SHT_AMD64_UNWIND 2777 */ 2778 if (column == 0) { 2779 /* 2780 * column == ET_REL 2781 */ 2782 if (process_section(name, ifl, shdr, 2783 scn, ndx, ld_targ.t_id.id_unwind, 2784 ofl) == S_ERROR) 2785 return (S_ERROR); 2786 ifl->ifl_isdesc[ndx]->is_flags |= 2787 FLG_IS_EHFRAME; 2788 } 2789 break; 2790 #endif 2791 default: 2792 do_default: 2793 if (process_section(name, ifl, shdr, scn, ndx, 2794 ((ident == ld_targ.t_id.id_null) ? 2795 ident : ld_targ.t_id.id_user), ofl) == 2796 S_ERROR) 2797 return (S_ERROR); 2798 break; 2799 } 2800 } 2801 } 2802 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 */ 2810 if (ifl->ifl_flags & FLG_IF_GROUPS) { 2811 for (ndx = 1; ndx < ifl->ifl_shnum; ndx++) { 2812 Is_desc *isp; 2813 2814 if (((isp = ifl->ifl_isdesc[ndx]) == NULL) || 2815 (isp->is_shdr->sh_type != SHT_GROUP)) 2816 continue; 2817 2818 if (ld_group_process(isp, ofl) == S_ERROR) 2819 return (S_ERROR); 2820 } 2821 } 2822 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 */ 2829 ld_comdat_validate(ofl, ifl); 2830 2831 /* 2832 * Now that all of the input sections have been processed, place 2833 * them in the appropriate output sections. 2834 */ 2835 for (ndx = 1; ndx < ifl->ifl_shnum; ndx++) { 2836 Is_desc *isp; 2837 2838 if (((isp = ifl->ifl_isdesc[ndx]) == NULL) || 2839 ((isp->is_flags & FLG_IS_PLACE) == 0)) 2840 continue; 2841 2842 /* 2843 * Place all non-ordered sections within their appropriate 2844 * output section. 2845 */ 2846 if ((isp->is_flags & FLG_IS_ORDERED) == 0) { 2847 if (ld_place_section(ofl, isp, path_info, 2848 isp->is_keyident, NULL) == (Os_desc *)S_ERROR) 2849 return (S_ERROR); 2850 continue; 2851 } 2852 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++; 2859 if (ordndx == 0) 2860 ordndx = ndx; 2861 } 2862 2863 /* 2864 * Having placed all the non-ordered sections, it is now 2865 * safe to place SHF_ORDERED/SHF_LINK_ORDER sections. 2866 */ 2867 if (ifl->ifl_flags & FLG_IF_ORDERED) { 2868 for (ndx = ordndx; ndx < ifl->ifl_shnum; ndx++) { 2869 Is_desc *isp; 2870 2871 if (((isp = ifl->ifl_isdesc[ndx]) == NULL) || 2872 ((isp->is_flags & 2873 (FLG_IS_PLACE | FLG_IS_ORDERED)) != 2874 (FLG_IS_PLACE | FLG_IS_ORDERED))) 2875 continue; 2876 2877 /* ld_process_ordered() calls ld_place_section() */ 2878 if (ld_process_ordered(ofl, ifl, path_info, ndx) == 2879 S_ERROR) 2880 return (S_ERROR); 2881 2882 /* If we've done them all, stop searching */ 2883 if (--ordcnt == 0) 2884 break; 2885 } 2886 } 2887 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 */ 2896 sdf = NULL; 2897 if (column && (ifl->ifl_flags & FLG_IF_NEEDED)) { 2898 const char *base; 2899 2900 /* 2901 * Use the basename of the input file (typically this is the 2902 * compilation environment name, ie. libfoo.so). 2903 */ 2904 if ((base = strrchr(ifl->ifl_name, '/')) == NULL) 2905 base = ifl->ifl_name; 2906 else 2907 base++; 2908 2909 if ((sdf = sdf_find(base, ofl->ofl_socntl)) != NULL) { 2910 sdf->sdf_file = ifl; 2911 ifl->ifl_sdfdesc = sdf; 2912 } 2913 } 2914 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 */ 2922 if (capisp && (process_cap(ofl, ifl, capisp) == S_ERROR)) 2923 return (S_ERROR); 2924 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 */ 2930 if (vndisp && ((ofl->ofl_flags & (FLG_OF_NOUNDEF | FLG_OF_SYMBOLIC)) || 2931 OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))) 2932 if (ld_vers_need_process(vndisp, ifl, ofl) == S_ERROR) 2933 return (S_ERROR); 2934 2935 /* 2936 * Before processing any symbol resolution or relocations process any 2937 * version sections. 2938 */ 2939 if (vsyisp) 2940 (void) ld_vers_sym_process(ofl, vsyisp, ifl); 2941 2942 if (ifl->ifl_versym && 2943 (vdfisp || (sdf && (sdf->sdf_flags & FLG_SDF_SELECT)))) 2944 if (ld_vers_def_process(vdfisp, ifl, ofl) == S_ERROR) 2945 return (S_ERROR); 2946 2947 /* 2948 * Having collected the appropriate sections carry out any additional 2949 * processing if necessary. 2950 */ 2951 for (ndx = 0; ndx < ifl->ifl_shnum; ndx++) { 2952 Is_desc *isp; 2953 2954 if ((isp = ifl->ifl_isdesc[ndx]) == NULL) 2955 continue; 2956 row = isp->is_shdr->sh_type; 2957 2958 if ((isp->is_flags & FLG_IS_DISCARD) == 0) 2959 ld_sup_section(ofl, isp->is_name, isp->is_shdr, ndx, 2960 isp->is_indata, elf); 2961 2962 /* 2963 * If this is a SHT_SUNW_move section from a relocatable file, 2964 * keep track of the section for later processing. 2965 */ 2966 if ((row == SHT_SUNW_move) && (column == 0)) { 2967 if (aplist_append(&(ofl->ofl_ismove), isp, 2968 AL_CNT_OFL_MOVE) == NULL) 2969 return (S_ERROR); 2970 } 2971 2972 /* 2973 * If this is a standard section type process it via the 2974 * appropriate action routine. 2975 */ 2976 if (row < SHT_NUM) { 2977 if (Final[row][column] != NULL) { 2978 if (Final[row][column](isp, ifl, 2979 ofl) == S_ERROR) 2980 return (S_ERROR); 2981 } 2982 #if defined(_ELF64) 2983 } else if ((row == SHT_AMD64_UNWIND) && (column == 0)) { 2984 Os_desc *osp = isp->is_osdesc; 2985 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 */ 2994 if (osp && (ld_targ.t_m.m_mach == EM_AMD64) && 2995 (ld_unwind_register(osp, ofl) == S_ERROR)) 2996 return (S_ERROR); 2997 #endif 2998 } 2999 } 3000 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 */ 3007 if (capinfoisp && (ifl->ifl_ehdr->e_type == ET_REL) && 3008 (process_capinfo(ofl, ifl, capinfoisp) == S_ERROR)) 3009 return (S_ERROR); 3010 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 */ 3016 if (sifisp && ((ifl->ifl_flags & (FLG_IF_NEEDED | FLG_IF_NODIRECT)) == 3017 (FLG_IF_NEEDED | FLG_IF_NODIRECT))) 3018 (void) ld_sym_nodirect(sifisp, ifl, ofl); 3019 3020 return (1); 3021 } 3022 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 3064 ld_process_ifl(const char *name, const char *soname, int fd, Elf *elf, 3065 Word flags, Ofl_desc *ofl, Rej_desc *rej, Ifl_desc **ifl_ret) 3066 { 3067 Ifl_desc *ifl; 3068 Ehdr *ehdr; 3069 uintptr_t error = 0; 3070 struct stat status; 3071 Ar_desc *adp; 3072 Rej_desc _rej; 3073 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 */ 3080 if (fd && ((flags & FLG_IF_EXTRACT) == 0)) 3081 (void) fstat(fd, &status); 3082 else { 3083 status.st_dev = 0; 3084 status.st_ino = 0; 3085 } 3086 3087 switch (elf_kind(elf)) { 3088 case ELF_K_AR: 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 */ 3095 if (ifl_ret != NULL) { 3096 _rej.rej_type = SGS_REJ_ARCHIVE; 3097 _rej.rej_name = name; 3098 DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej, 3099 ld_targ.t_m.m_mach)); 3100 if (rej->rej_type == 0) { 3101 *rej = _rej; 3102 rej->rej_name = strdup(_rej.rej_name); 3103 } 3104 return (0); 3105 } 3106 3107 /* 3108 * Determine if we've already come across this archive file. 3109 */ 3110 if (!(flags & FLG_IF_EXTRACT)) { 3111 Aliste idx; 3112 3113 for (APLIST_TRAVERSE(ofl->ofl_ars, idx, adp)) { 3114 if ((adp->ad_stdev != status.st_dev) || 3115 (adp->ad_stino != status.st_ino)) 3116 continue; 3117 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 */ 3125 DBG_CALL(Dbg_file_reuse(ofl->ofl_lml, name, 3126 adp->ad_name)); 3127 (void) elf_end(elf); 3128 if (!ld_process_archive(name, -1, adp, ofl)) 3129 return (S_ERROR); 3130 return (1); 3131 } 3132 } 3133 3134 /* 3135 * As we haven't processed this file before establish a new 3136 * archive descriptor. 3137 */ 3138 adp = ld_ar_setup(name, elf, ofl); 3139 if ((adp == NULL) || (adp == (Ar_desc *)S_ERROR)) 3140 return ((uintptr_t)adp); 3141 adp->ad_stdev = status.st_dev; 3142 adp->ad_stino = status.st_ino; 3143 3144 ld_sup_file(ofl, name, ELF_K_AR, flags, elf); 3145 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 */ 3158 if (elf_cntl(elf, ELF_C_FDREAD) == -1) { 3159 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_CNTL), 3160 name); 3161 return (0); 3162 } 3163 3164 if (!ld_process_archive(name, -1, adp, ofl)) 3165 return (S_ERROR); 3166 return (1); 3167 3168 case ELF_K_ELF: 3169 /* 3170 * Obtain the elf header so that we can determine what type of 3171 * elf ELF_K_ELF file this is. 3172 */ 3173 if ((ehdr = elf_getehdr(elf)) == NULL) { 3174 int _class = gelf_getclass(elf); 3175 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 */ 3183 if (ld_targ.t_m.m_class != _class) { 3184 _rej.rej_type = SGS_REJ_CLASS; 3185 _rej.rej_info = (uint_t)_class; 3186 } else { 3187 _rej.rej_type = SGS_REJ_STR; 3188 _rej.rej_str = elf_errmsg(-1); 3189 } 3190 _rej.rej_name = name; 3191 DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej, 3192 ld_targ.t_m.m_mach)); 3193 if (rej->rej_type == 0) { 3194 *rej = _rej; 3195 rej->rej_name = strdup(_rej.rej_name); 3196 } 3197 return (0); 3198 } 3199 3200 /* 3201 * Determine if we've already come across this file. 3202 */ 3203 if (!(flags & FLG_IF_EXTRACT)) { 3204 APlist *apl; 3205 Aliste idx; 3206 3207 if (ehdr->e_type == ET_REL) 3208 apl = ofl->ofl_objs; 3209 else 3210 apl = ofl->ofl_sos; 3211 3212 /* 3213 * Traverse the appropriate file list and determine if 3214 * a dev/inode match is found. 3215 */ 3216 for (APLIST_TRAVERSE(apl, idx, ifl)) { 3217 /* 3218 * Ifl_desc generated via -Nneed, therefore no 3219 * actual file behind it. 3220 */ 3221 if (ifl->ifl_flags & FLG_IF_NEEDSTR) 3222 continue; 3223 3224 if ((ifl->ifl_stino != status.st_ino) || 3225 (ifl->ifl_stdev != status.st_dev)) 3226 continue; 3227 3228 /* 3229 * Disregard (skip) this image. 3230 */ 3231 DBG_CALL(Dbg_file_skip(ofl->ofl_lml, 3232 ifl->ifl_name, name)); 3233 (void) elf_end(elf); 3234 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 */ 3243 if ((flags & FLG_IF_CMDLINE) || 3244 (ifl->ifl_flags & FLG_IF_CMDLINE)) { 3245 const char *errmsg; 3246 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 = 3254 (strcmp(name, ifl->ifl_name) == 0) ? 3255 MSG_INTL(MSG_FIL_MULINC_1) : 3256 MSG_INTL(MSG_FIL_MULINC_2); 3257 ld_eprintf(ofl, ERR_WARNING, 3258 errmsg, name, ifl->ifl_name); 3259 } 3260 if (ifl_ret) 3261 *ifl_ret = ifl; 3262 return (1); 3263 } 3264 } 3265 3266 /* 3267 * At this point, we know we need the file. Establish an input 3268 * file descriptor and continue processing. 3269 */ 3270 ifl = ifl_setup(name, ehdr, elf, flags, ofl, rej); 3271 if ((ifl == NULL) || (ifl == (Ifl_desc *)S_ERROR)) 3272 return ((uintptr_t)ifl); 3273 ifl->ifl_stdev = status.st_dev; 3274 ifl->ifl_stino = status.st_ino; 3275 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 */ 3281 if (ofl->ofl_flags1 & FLG_OF1_IGNORE) 3282 ifl->ifl_flags |= FLG_IF_IGNORE; 3283 3284 switch (ehdr->e_type) { 3285 case ET_REL: 3286 (*ld_targ.t_mr.mr_mach_eflags)(ehdr, ofl); 3287 error = process_elf(ifl, elf, ofl); 3288 break; 3289 case ET_DYN: 3290 if ((ofl->ofl_flags & FLG_OF_STATIC) || 3291 !(ofl->ofl_flags & FLG_OF_DYNLIBS)) { 3292 ld_eprintf(ofl, ERR_FATAL, 3293 MSG_INTL(MSG_FIL_SOINSTAT), name); 3294 return (0); 3295 } 3296 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 */ 3305 if (soname == NULL) 3306 ifl->ifl_soname = ifl->ifl_name; 3307 else 3308 ifl->ifl_soname = soname; 3309 3310 /* 3311 * If direct bindings, lazy loading, group permissions, 3312 * or deferred dependencies need to be established, mark 3313 * this object. 3314 */ 3315 if (ofl->ofl_flags1 & FLG_OF1_ZDIRECT) 3316 ifl->ifl_flags |= FLG_IF_DIRECT; 3317 if (ofl->ofl_flags1 & FLG_OF1_LAZYLD) 3318 ifl->ifl_flags |= FLG_IF_LAZYLD; 3319 if (ofl->ofl_flags1 & FLG_OF1_GRPPRM) 3320 ifl->ifl_flags |= FLG_IF_GRPPRM; 3321 if (ofl->ofl_flags1 & FLG_OF1_DEFERRED) 3322 ifl->ifl_flags |= 3323 (FLG_IF_LAZYLD | FLG_IF_DEFERRED); 3324 3325 error = process_elf(ifl, elf, ofl); 3326 3327 /* 3328 * Determine whether this dependency requires a syminfo. 3329 */ 3330 if (ifl->ifl_flags & MSK_IF_SYMINFO) 3331 ofl->ofl_flags |= FLG_OF_SYMINFO; 3332 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 */ 3338 if (OFL_GUIDANCE(ofl, FLG_OFG_NO_LAZY) && 3339 ((ifl->ifl_flags & FLG_IF_RTLDINF) == 0)) { 3340 ld_eprintf(ofl, ERR_GUIDANCE, 3341 MSG_INTL(MSG_GUIDE_LAZYLOAD)); 3342 ofl->ofl_guideflags |= FLG_OFG_NO_LAZY; 3343 } 3344 3345 /* 3346 * Guidance: Use -B direct/nodirect or 3347 * -z direct/nodirect. 3348 */ 3349 if (OFL_GUIDANCE(ofl, FLG_OFG_NO_DB)) { 3350 ld_eprintf(ofl, ERR_GUIDANCE, 3351 MSG_INTL(MSG_GUIDE_DIRECT)); 3352 ofl->ofl_guideflags |= FLG_OFG_NO_DB; 3353 } 3354 3355 break; 3356 default: 3357 (void) elf_errno(); 3358 _rej.rej_type = SGS_REJ_UNKFILE; 3359 _rej.rej_name = name; 3360 DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej, 3361 ld_targ.t_m.m_mach)); 3362 if (rej->rej_type == 0) { 3363 *rej = _rej; 3364 rej->rej_name = strdup(_rej.rej_name); 3365 } 3366 return (0); 3367 } 3368 break; 3369 default: 3370 (void) elf_errno(); 3371 _rej.rej_type = SGS_REJ_UNKFILE; 3372 _rej.rej_name = name; 3373 DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej, 3374 ld_targ.t_m.m_mach)); 3375 if (rej->rej_type == 0) { 3376 *rej = _rej; 3377 rej->rej_name = strdup(_rej.rej_name); 3378 } 3379 return (0); 3380 } 3381 if ((error == 0) || (error == S_ERROR)) 3382 return (error); 3383 3384 if (ifl_ret) 3385 *ifl_ret = ifl; 3386 return (1); 3387 } 3388 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 3396 ld_process_open(const char *opath, const char *ofile, int *fd, Ofl_desc *ofl, 3397 Word flags, Rej_desc *rej, Ifl_desc **ifl_ret) 3398 { 3399 Elf *elf; 3400 const char *npath = opath; 3401 const char *nfile = ofile; 3402 3403 if ((elf = elf_begin(*fd, ELF_C_READ, NULL)) == NULL) { 3404 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_BEGIN), npath); 3405 return (0); 3406 } 3407 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 */ 3421 ld_sup_open(ofl, &npath, &nfile, fd, flags, &elf, NULL, 0, 3422 elf_kind(elf)); 3423 3424 if ((*fd == -1) || (elf == NULL)) 3425 return (0); 3426 3427 return (ld_process_ifl(npath, nfile, *fd, elf, flags, ofl, rej, 3428 ifl_ret)); 3429 } 3430 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 * 3437 ld_process_mem(const char *path, const char *file, char *addr, size_t size, 3438 Ofl_desc *ofl, Rej_desc *rej) 3439 { 3440 Elf *elf; 3441 uintptr_t open_ret; 3442 Ifl_desc *ifl; 3443 3444 if ((elf = elf_memory(addr, size)) == NULL) { 3445 ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_MEMORY), path); 3446 return (0); 3447 } 3448 3449 open_ret = ld_process_ifl(path, file, 0, elf, 0, ofl, rej, &ifl); 3450 if (open_ret != 1) 3451 return ((Ifl_desc *) open_ret); 3452 return (ifl); 3453 } 3454 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 */ 3460 static Ifl_desc * 3461 process_req_lib(Sdf_desc *sdf, const char *dir, const char *file, 3462 Ofl_desc *ofl, Rej_desc *rej) 3463 { 3464 size_t dlen, plen; 3465 int fd; 3466 char path[PATH_MAX]; 3467 const char *_dir = dir; 3468 3469 /* 3470 * Determine the sizes of the directory and filename to insure we don't 3471 * exceed our buffer. 3472 */ 3473 if ((dlen = strlen(dir)) == 0) { 3474 _dir = MSG_ORIG(MSG_STR_DOT); 3475 dlen = 1; 3476 } 3477 dlen++; 3478 plen = dlen + strlen(file) + 1; 3479 if (plen > PATH_MAX) { 3480 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_PTHTOLONG), 3481 _dir, file); 3482 return (0); 3483 } 3484 3485 /* 3486 * Build the entire pathname and try and open the file. 3487 */ 3488 (void) strcpy(path, _dir); 3489 (void) strcat(path, MSG_ORIG(MSG_STR_SLASH)); 3490 (void) strcat(path, file); 3491 DBG_CALL(Dbg_libs_req(ofl->ofl_lml, sdf->sdf_name, 3492 sdf->sdf_rfile, path)); 3493 3494 if ((fd = open(path, O_RDONLY)) == -1) 3495 return (0); 3496 else { 3497 uintptr_t open_ret; 3498 Ifl_desc *ifl; 3499 char *_path; 3500 3501 if ((_path = libld_malloc(strlen(path) + 1)) == NULL) 3502 return ((Ifl_desc *)S_ERROR); 3503 (void) strcpy(_path, path); 3504 open_ret = ld_process_open(_path, &_path[dlen], &fd, ofl, 3505 0, rej, &ifl); 3506 if (fd != -1) 3507 (void) close(fd); 3508 if (open_ret != 1) 3509 return ((Ifl_desc *)open_ret); 3510 return (ifl); 3511 } 3512 } 3513 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 3527 ld_finish_libs(Ofl_desc *ofl) 3528 { 3529 Aliste idx1; 3530 Sdf_desc *sdf; 3531 Rej_desc rej = { 0 }; 3532 3533 /* 3534 * Make sure we are back in dynamic mode. 3535 */ 3536 ofl->ofl_flags |= FLG_OF_DYNLIBS; 3537 3538 for (APLIST_TRAVERSE(ofl->ofl_soneed, idx1, sdf)) { 3539 Aliste idx2; 3540 char *path, *slash = NULL; 3541 int fd; 3542 Ifl_desc *ifl; 3543 char *file = (char *)sdf->sdf_name; 3544 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 */ 3552 if (sdf->sdf_file) 3553 continue; 3554 3555 for (APLIST_TRAVERSE(ofl->ofl_sos, idx2, ifl)) { 3556 if (!(ifl->ifl_flags & FLG_IF_NEEDSTR) && 3557 (strcmp(file, ifl->ifl_soname) == 0)) { 3558 sdf->sdf_file = ifl; 3559 break; 3560 } 3561 } 3562 if (sdf->sdf_file) 3563 continue; 3564 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 */ 3570 for (path = file; *path; path++) { 3571 if (*path == '/') 3572 slash = path; 3573 } 3574 if (slash) { 3575 DBG_CALL(Dbg_libs_req(ofl->ofl_lml, sdf->sdf_name, 3576 sdf->sdf_rfile, file)); 3577 if ((fd = open(file, O_RDONLY)) == -1) { 3578 ld_eprintf(ofl, ERR_WARNING, 3579 MSG_INTL(MSG_FIL_NOTFOUND), file, 3580 sdf->sdf_rfile); 3581 } else { 3582 uintptr_t open_ret; 3583 Rej_desc _rej = { 0 }; 3584 3585 open_ret = ld_process_open(file, ++slash, 3586 &fd, ofl, 0, &_rej, &ifl); 3587 if (fd != -1) 3588 (void) close(fd); 3589 if (open_ret == S_ERROR) 3590 return (S_ERROR); 3591 3592 if (_rej.rej_type) { 3593 Conv_reject_desc_buf_t rej_buf; 3594 3595 ld_eprintf(ofl, ERR_WARNING, 3596 MSG_INTL(reject[_rej.rej_type]), 3597 _rej.rej_name ? rej.rej_name : 3598 MSG_INTL(MSG_STR_UNKNOWN), 3599 conv_reject_desc(&_rej, &rej_buf, 3600 ld_targ.t_m.m_mach)); 3601 } else 3602 sdf->sdf_file = ifl; 3603 } 3604 continue; 3605 } 3606 3607 /* 3608 * Now search for this file in any user defined directories. 3609 */ 3610 for (APLIST_TRAVERSE(ofl->ofl_ulibdirs, idx2, path)) { 3611 Rej_desc _rej = { 0 }; 3612 3613 ifl = process_req_lib(sdf, path, file, ofl, &_rej); 3614 if (ifl == (Ifl_desc *)S_ERROR) { 3615 return (S_ERROR); 3616 } 3617 if (_rej.rej_type) { 3618 if (rej.rej_type == 0) { 3619 rej = _rej; 3620 rej.rej_name = strdup(_rej.rej_name); 3621 } 3622 } 3623 if (ifl) { 3624 sdf->sdf_file = ifl; 3625 break; 3626 } 3627 } 3628 if (sdf->sdf_file) 3629 continue; 3630 3631 /* 3632 * Next use the local rules defined within the parent shared 3633 * object. 3634 */ 3635 if (sdf->sdf_rpath != NULL) { 3636 char *rpath, *next; 3637 3638 rpath = libld_malloc(strlen(sdf->sdf_rpath) + 1); 3639 if (rpath == NULL) 3640 return (S_ERROR); 3641 (void) strcpy(rpath, sdf->sdf_rpath); 3642 DBG_CALL(Dbg_libs_path(ofl->ofl_lml, rpath, 3643 LA_SER_RUNPATH, sdf->sdf_rfile)); 3644 if ((path = strtok_r(rpath, 3645 MSG_ORIG(MSG_STR_COLON), &next)) != NULL) { 3646 do { 3647 Rej_desc _rej = { 0 }; 3648 3649 path = expand(sdf->sdf_rfile, path, 3650 &next); 3651 3652 ifl = process_req_lib(sdf, path, 3653 file, ofl, &_rej); 3654 if (ifl == (Ifl_desc *)S_ERROR) { 3655 return (S_ERROR); 3656 } 3657 if ((_rej.rej_type) && 3658 (rej.rej_type == 0)) { 3659 rej = _rej; 3660 rej.rej_name = 3661 strdup(_rej.rej_name); 3662 } 3663 if (ifl) { 3664 sdf->sdf_file = ifl; 3665 break; 3666 } 3667 } while ((path = strtok_r(NULL, 3668 MSG_ORIG(MSG_STR_COLON), &next)) != NULL); 3669 } 3670 } 3671 if (sdf->sdf_file) 3672 continue; 3673 3674 /* 3675 * Finally try the default library search directories. 3676 */ 3677 for (APLIST_TRAVERSE(ofl->ofl_dlibdirs, idx2, path)) { 3678 Rej_desc _rej = { 0 }; 3679 3680 ifl = process_req_lib(sdf, path, file, ofl, &rej); 3681 if (ifl == (Ifl_desc *)S_ERROR) { 3682 return (S_ERROR); 3683 } 3684 if (_rej.rej_type) { 3685 if (rej.rej_type == 0) { 3686 rej = _rej; 3687 rej.rej_name = strdup(_rej.rej_name); 3688 } 3689 } 3690 if (ifl) { 3691 sdf->sdf_file = ifl; 3692 break; 3693 } 3694 } 3695 if (sdf->sdf_file) 3696 continue; 3697 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 */ 3704 if (rej.rej_type) { 3705 Conv_reject_desc_buf_t rej_buf; 3706 3707 ld_eprintf(ofl, ERR_WARNING, 3708 MSG_INTL(reject[rej.rej_type]), 3709 rej.rej_name ? rej.rej_name : 3710 MSG_INTL(MSG_STR_UNKNOWN), 3711 conv_reject_desc(&rej, &rej_buf, 3712 ld_targ.t_m.m_mach)); 3713 } else { 3714 ld_eprintf(ofl, ERR_WARNING, 3715 MSG_INTL(MSG_FIL_NOTFOUND), file, sdf->sdf_rfile); 3716 } 3717 } 3718 3719 /* 3720 * Finally, now that all objects have been input, make sure any version 3721 * requirements have been met. 3722 */ 3723 return (ld_vers_verify(ofl)); 3724 } 3725