1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1988 AT&T 24 * All Rights Reserved 25 * 26 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 */ 29 #pragma ident "%Z%%M% %I% %E% SMI" 30 31 /* 32 * Processing of relocatable objects and shared objects. 33 */ 34 35 #define ELF_TARGET_AMD64 36 #define ELF_TARGET_SPARC 37 38 #include <stdio.h> 39 #include <string.h> 40 #include <fcntl.h> 41 #include <unistd.h> 42 #include <link.h> 43 #include <limits.h> 44 #include <sys/stat.h> 45 #include <sys/systeminfo.h> 46 #include <debug.h> 47 #include <msg.h> 48 #include <_libld.h> 49 50 /* 51 * Decide if we can link against this input file. 52 */ 53 static int 54 ifl_verify(Ehdr * ehdr, Ofl_desc * ofl, Rej_desc * rej) 55 { 56 /* 57 * Check the validity of the elf header information for compatibility 58 * with this machine and our own internal elf library. 59 */ 60 if ((ehdr->e_machine != ld_targ.t_m.m_mach) && 61 ((ehdr->e_machine != ld_targ.t_m.m_machplus) && 62 ((ehdr->e_flags & ld_targ.t_m.m_flagsplus) == 0))) { 63 rej->rej_type = SGS_REJ_MACH; 64 rej->rej_info = (uint_t)ehdr->e_machine; 65 return (0); 66 } 67 if (ehdr->e_ident[EI_DATA] != ld_targ.t_m.m_data) { 68 rej->rej_type = SGS_REJ_DATA; 69 rej->rej_info = (uint_t)ehdr->e_ident[EI_DATA]; 70 return (0); 71 } 72 if (ehdr->e_version > ofl->ofl_dehdr->e_version) { 73 rej->rej_type = SGS_REJ_VERSION; 74 rej->rej_info = (uint_t)ehdr->e_version; 75 return (0); 76 } 77 return (1); 78 } 79 80 /* 81 * Check sanity of file header and allocate an infile descriptor 82 * for the file being processed. 83 */ 84 static Ifl_desc * 85 ifl_setup(const char *name, Ehdr *ehdr, Elf *elf, Word flags, Ofl_desc *ofl, 86 Rej_desc *rej) 87 { 88 Ifl_desc *ifl; 89 List *list; 90 Rej_desc _rej = { 0 }; 91 92 if (ifl_verify(ehdr, ofl, &_rej) == 0) { 93 _rej.rej_name = name; 94 DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej, 95 ld_targ.t_m.m_mach)); 96 if (rej->rej_type == 0) { 97 *rej = _rej; 98 rej->rej_name = strdup(_rej.rej_name); 99 } 100 return (0); 101 } 102 103 if ((ifl = libld_calloc(1, sizeof (Ifl_desc))) == 0) 104 return ((Ifl_desc *)S_ERROR); 105 ifl->ifl_name = name; 106 ifl->ifl_ehdr = ehdr; 107 ifl->ifl_elf = elf; 108 ifl->ifl_flags = flags; 109 110 /* 111 * Is this file using 'extended Section Indexes'. If so, use the 112 * e_shnum & e_shstrndx which can be found at: 113 * 114 * e_shnum == Shdr[0].sh_size 115 * e_shstrndx == Shdr[0].sh_link 116 */ 117 if ((ehdr->e_shnum == 0) && (ehdr->e_shoff != 0)) { 118 Elf_Scn *scn; 119 Shdr *shdr0; 120 121 if ((scn = elf_getscn(elf, 0)) == NULL) { 122 eprintf(ofl->ofl_lml, ERR_ELF, 123 MSG_INTL(MSG_ELF_GETSCN), name); 124 ofl->ofl_flags |= FLG_OF_FATAL; 125 return ((Ifl_desc *)S_ERROR); 126 } 127 if ((shdr0 = elf_getshdr(scn)) == NULL) { 128 eprintf(ofl->ofl_lml, ERR_ELF, 129 MSG_INTL(MSG_ELF_GETSHDR), name); 130 ofl->ofl_flags |= FLG_OF_FATAL; 131 return ((Ifl_desc *)S_ERROR); 132 } 133 ifl->ifl_shnum = (Word)shdr0->sh_size; 134 if (ehdr->e_shstrndx == SHN_XINDEX) 135 ifl->ifl_shstrndx = shdr0->sh_link; 136 else 137 ifl->ifl_shstrndx = ehdr->e_shstrndx; 138 } else { 139 ifl->ifl_shnum = ehdr->e_shnum; 140 ifl->ifl_shstrndx = ehdr->e_shstrndx; 141 } 142 143 if ((ifl->ifl_isdesc = libld_calloc(ifl->ifl_shnum, 144 sizeof (Is_desc *))) == 0) 145 return ((Ifl_desc *)S_ERROR); 146 147 /* 148 * Record this new input file on the shared object or relocatable 149 * object input file list. 150 */ 151 if (ifl->ifl_ehdr->e_type == ET_DYN) { 152 list = &ofl->ofl_sos; 153 } else { 154 list = &ofl->ofl_objs; 155 } 156 157 if (list_appendc(list, ifl) == 0) 158 return ((Ifl_desc *)S_ERROR); 159 return (ifl); 160 } 161 162 /* 163 * Process a generic section. The appropriate section information is added 164 * to the files input descriptor list. 165 */ 166 static uintptr_t 167 process_section(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 168 Word ndx, int ident, Ofl_desc *ofl) 169 { 170 Is_desc *isp; 171 172 /* 173 * Create a new input section descriptor. If this is a NOBITS 174 * section elf_getdata() will still create a data buffer (the buffer 175 * will be null and the size will reflect the actual memory size). 176 */ 177 if ((isp = libld_calloc(sizeof (Is_desc), 1)) == 0) 178 return (S_ERROR); 179 isp->is_shdr = shdr; 180 isp->is_file = ifl; 181 isp->is_name = name; 182 isp->is_scnndx = ndx; 183 isp->is_flags = FLG_IS_EXTERNAL; 184 /* LINTED */ 185 isp->is_key = (Half)ident; 186 if ((isp->is_indata = elf_getdata(scn, NULL)) == NULL) { 187 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETDATA), 188 ifl->ifl_name); 189 ofl->ofl_flags |= FLG_OF_FATAL; 190 return (0); 191 } 192 193 if ((shdr->sh_flags & SHF_EXCLUDE) && 194 ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) { 195 isp->is_flags |= FLG_IS_DISCARD; 196 } 197 198 /* 199 * Add the new input section to the files input section list and 200 * to the output section list (some sections like .strtab and 201 * .shstrtab are not added to the output section list). 202 * 203 * If the section has the SHF_ORDERED flag on, do the ld_place_section() 204 * after all input sections from this file are read in. 205 */ 206 ifl->ifl_isdesc[ndx] = isp; 207 if (ident && (shdr->sh_flags & ALL_SHF_ORDER) == 0) 208 return ((uintptr_t)ld_place_section(ofl, isp, ident, 0)); 209 210 if (ident && (shdr->sh_flags & ALL_SHF_ORDER)) { 211 isp->is_flags |= FLG_IS_ORDERED; 212 isp->is_ident = ident; 213 214 if ((ndx != 0) && (ndx == shdr->sh_link) && 215 (shdr->sh_flags & SHF_ORDERED)) { 216 return ((uintptr_t)ld_place_section(ofl, isp, 217 ident, 0)); 218 } 219 } 220 return (1); 221 } 222 223 /* 224 * Determine the software capabilities of the object being built from the 225 * capabilities of the input relocatable objects. One software capability 226 * is presently recognized, and represented with the following (sys/elf.h): 227 * 228 * SF1_SUNW_FPKNWN use/non-use of frame pointer is known, and 229 * SF1_SUNW_FPUSED the frame pointer is in use. 230 * 231 * The resolution of the present fame pointer state, and the capabilities 232 * provided by a new input relocatable object are: 233 * 234 * new input relocatable object 235 * 236 * present | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | <unknown> 237 * state | SF1_SUNW_FPUSED | | 238 * --------------------------------------------------------------------------- 239 * SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN 240 * SF1_SUNW_FPUSED | SF1_SUNW_FPUSED | | SF1_SUNW_FPUSED 241 * --------------------------------------------------------------------------- 242 * SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN 243 * | | | 244 * --------------------------------------------------------------------------- 245 * <unknown> | SF1_SUNW_FPKNWN | SF1_SUNW_FPKNWN | <unknown> 246 * | SF1_SUNW_FPUSED | | 247 */ 248 static void 249 sf1_cap(Ofl_desc *ofl, Xword val, Ifl_desc *ifl, const char *name) 250 { 251 Xword badval; 252 253 /* 254 * If a mapfile has established definitions to override any input 255 * capabilities, ignore any new input capabilities. 256 */ 257 if (ofl->ofl_flags1 & FLG_OF1_OVSFCAP) { 258 Dbg_cap_sec_entry(ofl->ofl_lml, DBG_CAP_IGNORE, CA_SUNW_SF_1, 259 val, ld_targ.t_m.m_mach); 260 return; 261 } 262 263 /* 264 * If this object doesn't specify any capabilities, ignore it, and 265 * leave the state as is. 266 */ 267 if (val == 0) 268 return; 269 270 /* 271 * Make sure we only accept known software capabilities. Note, that 272 * an F1_SUNW_FPUSED by itself is viewed as bad practice. 273 */ 274 if ((badval = (val & ~SF1_SUNW_MASK)) != 0) { 275 eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_FIL_BADSF1), 276 ifl->ifl_name, name, EC_XWORD(badval)); 277 val &= SF1_SUNW_MASK; 278 } 279 if (val == SF1_SUNW_FPUSED) { 280 eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_FIL_BADSF1), 281 ifl->ifl_name, name, EC_XWORD(val)); 282 return; 283 } 284 285 Dbg_cap_sec_entry(ofl->ofl_lml, DBG_CAP_OLD, CA_SUNW_SF_1, 286 ofl->ofl_sfcap_1, ld_targ.t_m.m_mach); 287 Dbg_cap_sec_entry(ofl->ofl_lml, DBG_CAP_NEW, CA_SUNW_SF_1, 288 val, ld_targ.t_m.m_mach); 289 290 /* 291 * Determine the resolution of the present frame pointer and the 292 * new input relocatable objects frame pointer. 293 */ 294 if ((ofl->ofl_sfcap_1 & (SF1_SUNW_FPKNWN | SF1_SUNW_FPUSED)) == 295 (SF1_SUNW_FPKNWN | SF1_SUNW_FPUSED)) { 296 /* 297 * If the new relocatable object isn't using a frame pointer, 298 * reduce the present state to unused. 299 */ 300 if ((val & (SF1_SUNW_FPKNWN | SF1_SUNW_FPUSED)) != 301 (SF1_SUNW_FPKNWN | SF1_SUNW_FPUSED)) 302 ofl->ofl_sfcap_1 &= ~SF1_SUNW_FPUSED; 303 304 } else if ((ofl->ofl_sfcap_1 & SF1_SUNW_FPKNWN) == 0) { 305 /* 306 * If the present state is unknown, take the new relocatable 307 * object frame pointer usage. 308 */ 309 ofl->ofl_sfcap_1 = val; 310 } 311 312 Dbg_cap_sec_entry(ofl->ofl_lml, DBG_CAP_RESOLVED, CA_SUNW_SF_1, 313 ofl->ofl_sfcap_1, ld_targ.t_m.m_mach); 314 } 315 316 /* 317 * Determine the hardware capabilities of the object being built from the 318 * capabilities of the input relocatable objects. There's really little to 319 * do here, other than to offer diagnostics, hardware capabilities are simply 320 * additive. 321 */ 322 static void 323 hw1_cap(Ofl_desc *ofl, Xword val) 324 { 325 /* 326 * If a mapfile has established definitions to override any input 327 * capabilities, ignore any new input capabilities. 328 */ 329 if (ofl->ofl_flags1 & FLG_OF1_OVHWCAP) { 330 Dbg_cap_sec_entry(ofl->ofl_lml, DBG_CAP_IGNORE, CA_SUNW_HW_1, 331 val, ld_targ.t_m.m_mach); 332 return; 333 } 334 335 /* 336 * If this object doesn't specify any capabilities, ignore it, and 337 * leave the state as is. 338 */ 339 if (val == 0) 340 return; 341 342 Dbg_cap_sec_entry(ofl->ofl_lml, DBG_CAP_OLD, CA_SUNW_HW_1, 343 ofl->ofl_hwcap_1, ld_targ.t_m.m_mach); 344 Dbg_cap_sec_entry(ofl->ofl_lml, DBG_CAP_NEW, CA_SUNW_HW_1, val, 345 ld_targ.t_m.m_mach); 346 347 ofl->ofl_hwcap_1 |= val; 348 349 Dbg_cap_sec_entry(ofl->ofl_lml, DBG_CAP_RESOLVED, CA_SUNW_HW_1, 350 ofl->ofl_hwcap_1, ld_targ.t_m.m_mach); 351 } 352 353 /* 354 * Process a hardware/software capabilities section. Traverse the section 355 * updating the global capabilities variables as necessary. 356 */ 357 static void 358 process_cap(Ifl_desc *ifl, Is_desc *cisp, Ofl_desc *ofl) 359 { 360 Cap *cdata; 361 Word ndx, cnum; 362 363 DBG_CALL(Dbg_cap_sec_title(ofl)); 364 365 /* 366 * The capabilities are supposed to be terminated with a CA_SUNW_NULL 367 * entry. However, the compilers have been known to not follow this 368 * convention. Use the section information to determine the number 369 * of capabilities, and skip any CA_SUNW_NULL entries. 370 */ 371 cdata = (Cap *)cisp->is_indata->d_buf; 372 cnum = (Word)(cisp->is_shdr->sh_size / cisp->is_shdr->sh_entsize); 373 374 for (ndx = 0; ndx < cnum; cdata++, ndx++) { 375 switch (cdata->c_tag) { 376 case CA_SUNW_HW_1: 377 hw1_cap(ofl, cdata->c_un.c_val); 378 break; 379 case CA_SUNW_SF_1: 380 sf1_cap(ofl, cdata->c_un.c_val, ifl, 381 cisp->is_name); 382 break; 383 case CA_SUNW_NULL: 384 break; 385 default: 386 eprintf(ofl->ofl_lml, ERR_WARNING, 387 MSG_INTL(MSG_FIL_UNKCAP), 388 ifl->ifl_name, cisp->is_name, cdata->c_tag); 389 } 390 } 391 } 392 393 /* 394 * Simply process the section so that we have pointers to the data for use 395 * in later routines, however don't add the section to the output section 396 * list as we will be creating our own replacement sections later (ie. 397 * symtab and relocation). 398 */ 399 static uintptr_t 400 /* ARGSUSED5 */ 401 process_input(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 402 Word ndx, int ident, Ofl_desc *ofl) 403 { 404 return (process_section(name, ifl, shdr, scn, ndx, 405 ld_targ.t_id.id_null, ofl)); 406 } 407 408 /* 409 * Keep a running count of relocation entries from input relocatable objects for 410 * sizing relocation buckets later. If we're building an executable, save any 411 * relocations from shared objects to determine if any copy relocation symbol 412 * has a displacement relocation against it. 413 */ 414 static uintptr_t 415 /* ARGSUSED5 */ 416 process_reloc(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 417 Word ndx, int ident, Ofl_desc *ofl) 418 { 419 if (process_section(name, ifl, 420 shdr, scn, ndx, ld_targ.t_id.id_null, ofl) == S_ERROR) 421 return (S_ERROR); 422 423 if (ifl->ifl_ehdr->e_type == ET_REL) { 424 if (shdr->sh_entsize && (shdr->sh_entsize <= shdr->sh_size)) 425 /* LINTED */ 426 ofl->ofl_relocincnt += 427 (Word)(shdr->sh_size / shdr->sh_entsize); 428 } else if (ofl->ofl_flags & FLG_OF_EXEC) { 429 if (list_appendc(&ifl->ifl_relsect, ifl->ifl_isdesc[ndx]) == 0) 430 return (S_ERROR); 431 } 432 return (1); 433 } 434 435 436 /* 437 * Process a string table section. A valid section contains an initial and 438 * final null byte. 439 */ 440 static uintptr_t 441 process_strtab(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 442 Word ndx, int ident, Ofl_desc *ofl) 443 { 444 char *data; 445 size_t size; 446 Is_desc *isp; 447 uintptr_t error; 448 449 /* 450 * Never include .stab.excl sections in any output file. 451 * If the -s flag has been specified strip any .stab sections. 452 */ 453 if (((ofl->ofl_flags & FLG_OF_STRIP) && ident && 454 (strncmp(name, MSG_ORIG(MSG_SCN_STAB), MSG_SCN_STAB_SIZE) == 0)) || 455 (strcmp(name, MSG_ORIG(MSG_SCN_STABEXCL)) == 0) && ident) 456 return (1); 457 458 /* 459 * If we got here to process a .shstrtab or .dynstr table, `ident' will 460 * be null. Otherwise make sure we don't have a .strtab section as this 461 * should not be added to the output section list either. 462 */ 463 if ((ident != ld_targ.t_id.id_null) && 464 (strcmp(name, MSG_ORIG(MSG_SCN_STRTAB)) == 0)) 465 ident = ld_targ.t_id.id_null; 466 467 error = process_section(name, ifl, shdr, scn, ndx, ident, ofl); 468 if ((error == 0) || (error == S_ERROR)) 469 return (error); 470 471 /* 472 * String tables should start and end with a NULL byte. Note, it has 473 * been known for the assembler to create empty string tables, so check 474 * the size before attempting to verify the data itself. 475 */ 476 isp = ifl->ifl_isdesc[ndx]; 477 size = isp->is_indata->d_size; 478 if (size) { 479 data = isp->is_indata->d_buf; 480 if (data[0] != '\0' || data[size - 1] != '\0') 481 eprintf(ofl->ofl_lml, ERR_WARNING, 482 MSG_INTL(MSG_FIL_MALSTR), ifl->ifl_name, name); 483 } else 484 isp->is_indata->d_buf = (void *)MSG_ORIG(MSG_STR_EMPTY); 485 486 ifl->ifl_flags |= FLG_IF_HSTRTAB; 487 return (1); 488 } 489 490 /* 491 * Invalid sections produce a warning and are skipped. 492 */ 493 static uintptr_t 494 /* ARGSUSED3 */ 495 invalid_section(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 496 Word ndx, int ident, Ofl_desc *ofl) 497 { 498 Conv_inv_buf_t inv_buf; 499 500 eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_FIL_INVALSEC), 501 ifl->ifl_name, name, conv_sec_type(ifl->ifl_ehdr->e_machine, 502 shdr->sh_type, 0, &inv_buf)); 503 return (1); 504 } 505 506 /* 507 * Process a progbits section. 508 */ 509 static uintptr_t 510 process_progbits(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 511 Word ndx, int ident, Ofl_desc *ofl) 512 { 513 int stab_index = 0; 514 515 /* 516 * Never include .stab.excl sections in any output file. 517 * If the -s flag has been specified strip any .stab sections. 518 */ 519 if (ident && (strncmp(name, MSG_ORIG(MSG_SCN_STAB), 520 MSG_SCN_STAB_SIZE) == 0)) { 521 if ((ofl->ofl_flags & FLG_OF_STRIP) || 522 (strcmp((name + MSG_SCN_STAB_SIZE), 523 MSG_ORIG(MSG_SCN_EXCL)) == 0)) 524 return (1); 525 526 if (strcmp((name + MSG_SCN_STAB_SIZE), 527 MSG_ORIG(MSG_SCN_INDEX)) == 0) 528 stab_index = 1; 529 } 530 531 if ((ofl->ofl_flags & FLG_OF_STRIP) && ident) { 532 if ((strncmp(name, MSG_ORIG(MSG_SCN_DEBUG), 533 MSG_SCN_DEBUG_SIZE) == 0) || 534 (strcmp(name, MSG_ORIG(MSG_SCN_LINE)) == 0)) 535 return (1); 536 } 537 538 /* 539 * Update the ident to reflect the type of section we've got. 540 * 541 * If there is any .plt or .got section to generate we'll be creating 542 * our own version, so don't allow any input sections of these types to 543 * be added to the output section list (why a relocatable object would 544 * have a .plt or .got is a mystery, but stranger things have occurred). 545 */ 546 if (ident) { 547 if (shdr->sh_flags & SHF_TLS) 548 ident = ld_targ.t_id.id_tls; 549 else if ((shdr->sh_flags & ~ALL_SHF_IGNORE) == 550 (SHF_ALLOC | SHF_EXECINSTR)) 551 ident = ld_targ.t_id.id_text; 552 else if (shdr->sh_flags & SHF_ALLOC) { 553 if ((strcmp(name, MSG_ORIG(MSG_SCN_PLT)) == 0) || 554 (strcmp(name, MSG_ORIG(MSG_SCN_GOT)) == 0)) 555 ident = ld_targ.t_id.id_null; 556 else if (stab_index) { 557 /* 558 * This is a work-around for x86 compilers that 559 * have set SHF_ALLOC for the .stab.index 560 * section. 561 * 562 * Because of this, make sure that the 563 * .stab.index does not end up as the last 564 * section in the text segment. Older linkers 565 * can produce segmentation violations when they 566 * strip (ld -s) against a shared object whose 567 * last section in the text segment is a .stab. 568 */ 569 ident = ld_targ.t_id.id_interp; 570 } else 571 ident = ld_targ.t_id.id_data; 572 } else 573 ident = ld_targ.t_id.id_note; 574 } 575 return (process_section(name, ifl, shdr, scn, ndx, ident, ofl)); 576 } 577 578 /* 579 * Handles the SHT_SUNW_{DEBUG,DEBUGSTR) sections. 580 */ 581 static uintptr_t 582 process_debug(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 583 Word ndx, int ident, Ofl_desc *ofl) 584 { 585 /* 586 * Debug information is discarded when the 'ld -s' flag is invoked. 587 */ 588 if (ofl->ofl_flags & FLG_OF_STRIP) { 589 return (1); 590 } 591 return (process_progbits(name, ifl, shdr, scn, ndx, ident, ofl)); 592 } 593 594 /* 595 * Process a nobits section. 596 */ 597 static uintptr_t 598 process_nobits(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 599 Word ndx, int ident, Ofl_desc *ofl) 600 { 601 if (ident) { 602 if (shdr->sh_flags & SHF_TLS) 603 ident = ld_targ.t_id.id_tlsbss; 604 #if defined(_ELF64) 605 else if ((shdr->sh_flags & SHF_AMD64_LARGE) && 606 (ld_targ.t_m.m_mach == EM_AMD64)) 607 ident = ld_targ.t_id.id_lbss; 608 #endif 609 else 610 ident = ld_targ.t_id.id_bss; 611 } 612 return (process_section(name, ifl, shdr, scn, ndx, ident, ofl)); 613 } 614 615 /* 616 * Process a SHT_*_ARRAY section. 617 */ 618 static uintptr_t 619 process_array(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 620 Word ndx, int ident, Ofl_desc *ofl) 621 { 622 Os_desc *osp; 623 Is_desc *isp; 624 625 if (ident) 626 ident = ld_targ.t_id.id_array; 627 628 if (process_section(name, ifl, shdr, scn, ndx, ident, ofl) == S_ERROR) 629 return (S_ERROR); 630 631 if (((isp = ifl->ifl_isdesc[ndx]) == 0) || 632 ((osp = isp->is_osdesc) == 0)) 633 return (0); 634 635 if ((shdr->sh_type == SHT_FINI_ARRAY) && 636 (ofl->ofl_osfiniarray == 0)) 637 ofl->ofl_osfiniarray = osp; 638 else if ((shdr->sh_type == SHT_INIT_ARRAY) && 639 (ofl->ofl_osinitarray == 0)) 640 ofl->ofl_osinitarray = osp; 641 else if ((shdr->sh_type == SHT_PREINIT_ARRAY) && 642 (ofl->ofl_ospreinitarray == 0)) 643 ofl->ofl_ospreinitarray = osp; 644 645 return (1); 646 } 647 648 /* 649 * Process a SHT_SYMTAB_SHNDX section. 650 */ 651 static uintptr_t 652 process_sym_shndx(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 653 Word ndx, int ident, Ofl_desc *ofl) 654 { 655 if (process_input(name, ifl, shdr, scn, ndx, ident, ofl) == S_ERROR) 656 return (S_ERROR); 657 658 /* 659 * Have we already seen the related SYMTAB - if so verify it now. 660 */ 661 if (shdr->sh_link < ndx) { 662 Is_desc *isp = ifl->ifl_isdesc[shdr->sh_link]; 663 664 if ((isp == 0) || ((isp->is_shdr->sh_type != SHT_SYMTAB) && 665 (isp->is_shdr->sh_type != SHT_DYNSYM))) { 666 eprintf(ofl->ofl_lml, ERR_FATAL, 667 MSG_INTL(MSG_FIL_INVSHLINK), ifl->ifl_name, name, 668 EC_XWORD(shdr->sh_link)); 669 return (S_ERROR); 670 } 671 isp->is_symshndx = ifl->ifl_isdesc[ndx]; 672 } 673 return (1); 674 } 675 676 /* 677 * Final processing for SHT_SYMTAB_SHNDX section. 678 */ 679 static uintptr_t 680 /* ARGSUSED2 */ 681 sym_shndx_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl) 682 { 683 if (isc->is_shdr->sh_link > isc->is_scnndx) { 684 Is_desc *isp = ifl->ifl_isdesc[isc->is_shdr->sh_link]; 685 686 if ((isp == 0) || ((isp->is_shdr->sh_type != SHT_SYMTAB) && 687 (isp->is_shdr->sh_type != SHT_DYNSYM))) { 688 eprintf(ofl->ofl_lml, ERR_FATAL, 689 MSG_INTL(MSG_FIL_INVSHLINK), isc->is_file->ifl_name, 690 isc->is_name, EC_XWORD(isc->is_shdr->sh_link)); 691 return (S_ERROR); 692 } 693 isp->is_symshndx = isc; 694 } 695 return (1); 696 } 697 698 /* 699 * Process .dynamic section from a relocatable object. 700 * 701 * Note: That the .dynamic section is only considered interesting when 702 * dlopen()ing a relocatable object (thus FLG_OF1_RELDYN can only get 703 * set when libld is called from ld.so.1). 704 */ 705 /*ARGSUSED*/ 706 static uintptr_t 707 process_rel_dynamic(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 708 Word ndx, int ident, Ofl_desc *ofl) 709 { 710 Dyn *dyn; 711 Elf_Scn *strscn; 712 Elf_Data *dp; 713 char *str; 714 715 /* 716 * Process .dynamic sections from relocatable objects ? 717 */ 718 if ((ofl->ofl_flags1 & FLG_OF1_RELDYN) == 0) 719 return (1); 720 721 /* 722 * Find the string section associated with the .dynamic section. 723 */ 724 if ((strscn = elf_getscn(ifl->ifl_elf, shdr->sh_link)) == NULL) { 725 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETSCN), 726 ifl->ifl_name); 727 ofl->ofl_flags |= FLG_OF_FATAL; 728 return (0); 729 } 730 dp = elf_getdata(strscn, NULL); 731 str = (char *)dp->d_buf; 732 733 /* 734 * And get the .dynamic data 735 */ 736 dp = elf_getdata(scn, NULL); 737 738 for (dyn = (Dyn *)dp->d_buf; dyn->d_tag != DT_NULL; dyn++) { 739 Ifl_desc *difl; 740 741 switch (dyn->d_tag) { 742 case DT_NEEDED: 743 case DT_USED: 744 if (((difl = 745 libld_calloc(1, sizeof (Ifl_desc))) == 0) || 746 (list_appendc(&ofl->ofl_sos, difl) == 0)) 747 return (S_ERROR); 748 749 difl->ifl_name = MSG_ORIG(MSG_STR_DYNAMIC); 750 difl->ifl_soname = str + (size_t)dyn->d_un.d_val; 751 difl->ifl_flags = FLG_IF_NEEDSTR; 752 break; 753 case DT_RPATH: 754 case DT_RUNPATH: 755 if ((ofl->ofl_rpath = add_string(ofl->ofl_rpath, 756 (str + (size_t)dyn->d_un.d_val))) == 757 (const char *)S_ERROR) 758 return (S_ERROR); 759 break; 760 case DT_VERSYM: 761 /* 762 * The Solaris ld does not put DT_VERSYM in the 763 * dynamic section. If the object has DT_VERSYM, 764 * then it must have been produced by the GNU ld, 765 * and is using the GNU style of versioning. 766 */ 767 ifl->ifl_flags |= FLG_IF_GNUVER; 768 break; 769 } 770 } 771 return (1); 772 } 773 774 /* 775 * Expand implicit references. Dependencies can be specified in terms of the 776 * $ORIGIN, $PLATFORM, $OSREL and $OSNAME tokens, either from their needed name, 777 * or via a runpath. In addition runpaths may also specify the $ISALIST token. 778 * 779 * Probably the most common reference to explicit dependencies (via -L) will be 780 * sufficient to find any associated implicit dependencies, but just in case we 781 * expand any occurrence of these known tokens here. 782 * 783 * Note, if any errors occur we simply return the original name. 784 * 785 * This code is remarkably similar to expand() in rtld/common/paths.c. 786 */ 787 static char *platform = 0; 788 static size_t platform_sz = 0; 789 static Isa_desc *isa = 0; 790 static Uts_desc *uts = 0; 791 792 static char * 793 expand(const char *parent, const char *name, char **next) 794 { 795 char _name[PATH_MAX], *nptr, *_next; 796 const char *optr; 797 size_t nrem = PATH_MAX - 1; 798 int expanded = 0, _expanded, isaflag = 0; 799 800 optr = name; 801 nptr = _name; 802 803 while (*optr) { 804 if (nrem == 0) 805 return ((char *)name); 806 807 if (*optr != '$') { 808 *nptr++ = *optr++, nrem--; 809 continue; 810 } 811 812 _expanded = 0; 813 814 if (strncmp(optr, MSG_ORIG(MSG_STR_ORIGIN), 815 MSG_STR_ORIGIN_SIZE) == 0) { 816 char *eptr; 817 818 /* 819 * For $ORIGIN, expansion is really just a concatenation 820 * of the parents directory name. For example, an 821 * explicit dependency foo/bar/lib1.so with a dependency 822 * on $ORIGIN/lib2.so would be expanded to 823 * foo/bar/lib2.so. 824 */ 825 if ((eptr = strrchr(parent, '/')) == 0) { 826 *nptr++ = '.'; 827 nrem--; 828 } else { 829 size_t len = eptr - parent; 830 831 if (len >= nrem) 832 return ((char *)name); 833 834 (void) strncpy(nptr, parent, len); 835 nptr = nptr + len; 836 nrem -= len; 837 } 838 optr += MSG_STR_ORIGIN_SIZE; 839 expanded = _expanded = 1; 840 841 } else if (strncmp(optr, MSG_ORIG(MSG_STR_PLATFORM), 842 MSG_STR_PLATFORM_SIZE) == 0) { 843 /* 844 * Establish the platform from sysconf - like uname -i. 845 */ 846 if ((platform == 0) && (platform_sz == 0)) { 847 char info[SYS_NMLN]; 848 long size; 849 850 size = sysinfo(SI_PLATFORM, info, SYS_NMLN); 851 if ((size != -1) && 852 (platform = libld_malloc((size_t)size))) { 853 (void) strcpy(platform, info); 854 platform_sz = (size_t)size - 1; 855 } else 856 platform_sz = 1; 857 } 858 if (platform != 0) { 859 if (platform_sz >= nrem) 860 return ((char *)name); 861 862 (void) strncpy(nptr, platform, platform_sz); 863 nptr = nptr + platform_sz; 864 nrem -= platform_sz; 865 866 optr += MSG_STR_PLATFORM_SIZE; 867 expanded = _expanded = 1; 868 } 869 870 } else if (strncmp(optr, MSG_ORIG(MSG_STR_OSNAME), 871 MSG_STR_OSNAME_SIZE) == 0) { 872 /* 873 * Establish the os name - like uname -s. 874 */ 875 if (uts == 0) 876 uts = conv_uts(); 877 878 if (uts && uts->uts_osnamesz) { 879 if (uts->uts_osnamesz >= nrem) 880 return ((char *)name); 881 882 (void) strncpy(nptr, uts->uts_osname, 883 uts->uts_osnamesz); 884 nptr = nptr + uts->uts_osnamesz; 885 nrem -= uts->uts_osnamesz; 886 887 optr += MSG_STR_OSNAME_SIZE; 888 expanded = _expanded = 1; 889 } 890 891 } else if (strncmp(optr, MSG_ORIG(MSG_STR_OSREL), 892 MSG_STR_OSREL_SIZE) == 0) { 893 /* 894 * Establish the os release - like uname -r. 895 */ 896 if (uts == 0) 897 uts = conv_uts(); 898 899 if (uts && uts->uts_osrelsz) { 900 if (uts->uts_osrelsz >= nrem) 901 return ((char *)name); 902 903 (void) strncpy(nptr, uts->uts_osrel, 904 uts->uts_osrelsz); 905 nptr = nptr + uts->uts_osrelsz; 906 nrem -= uts->uts_osrelsz; 907 908 optr += MSG_STR_OSREL_SIZE; 909 expanded = _expanded = 1; 910 } 911 912 } else if ((strncmp(optr, MSG_ORIG(MSG_STR_ISALIST), 913 MSG_STR_ISALIST_SIZE) == 0) && next && (isaflag++ == 0)) { 914 /* 915 * Establish instruction sets from sysconf. Note that 916 * this is only meaningful from runpaths. 917 */ 918 if (isa == 0) 919 isa = conv_isalist(); 920 921 if (isa && isa->isa_listsz && 922 (nrem > isa->isa_opt->isa_namesz)) { 923 size_t mlen, tlen, hlen = optr - name; 924 size_t no; 925 char *lptr; 926 Isa_opt *opt = isa->isa_opt; 927 928 (void) strncpy(nptr, opt->isa_name, 929 opt->isa_namesz); 930 nptr = nptr + opt->isa_namesz; 931 nrem -= opt->isa_namesz; 932 933 optr += MSG_STR_ISALIST_SIZE; 934 expanded = _expanded = 1; 935 936 tlen = strlen(optr); 937 938 /* 939 * As ISALIST expands to a number of elements, 940 * establish a new list to return to the caller. 941 * This will contain the present path being 942 * processed redefined for each isalist option, 943 * plus the original remaining list entries. 944 */ 945 mlen = ((hlen + tlen) * (isa->isa_optno - 1)) + 946 isa->isa_listsz - opt->isa_namesz; 947 if (*next) 948 mlen += strlen(*next); 949 if ((_next = lptr = libld_malloc(mlen)) == 0) 950 return (0); 951 952 for (no = 1, opt++; no < isa->isa_optno; 953 no++, opt++) { 954 (void) strncpy(lptr, name, hlen); 955 lptr = lptr + hlen; 956 (void) strncpy(lptr, opt->isa_name, 957 opt->isa_namesz); 958 lptr = lptr + opt->isa_namesz; 959 (void) strncpy(lptr, optr, tlen); 960 lptr = lptr + tlen; 961 *lptr++ = ':'; 962 } 963 if (*next) 964 (void) strcpy(lptr, *next); 965 else 966 *--lptr = '\0'; 967 } 968 } 969 970 /* 971 * If no expansion occurred skip the $ and continue. 972 */ 973 if (_expanded == 0) 974 *nptr++ = *optr++, nrem--; 975 } 976 977 /* 978 * If any ISALIST processing has occurred not only do we return the 979 * expanded node we're presently working on, but we must also update the 980 * remaining list so that it is effectively prepended with this node 981 * expanded to all remaining isalist options. Note that we can only 982 * handle one ISALIST per node. For more than one ISALIST to be 983 * processed we'd need a better algorithm than above to replace the 984 * newly generated list. Whether we want to encourage the number of 985 * pathname permutations this would provide is another question. So, for 986 * now if more than one ISALIST is encountered we return the original 987 * node untouched. 988 */ 989 if (isaflag) { 990 if (isaflag == 1) 991 *next = _next; 992 else 993 return ((char *)name); 994 } 995 996 *nptr = '\0'; 997 998 if (expanded) { 999 if ((nptr = libld_malloc(strlen(_name) + 1)) == 0) 1000 return ((char *)name); 1001 (void) strcpy(nptr, _name); 1002 return (nptr); 1003 } 1004 return ((char *)name); 1005 } 1006 1007 /* 1008 * The Solaris ld does not put DT_VERSYM in the dynamic section, but the 1009 * GNU ld does, and it is used by the runtime linker to implement their 1010 * versioning scheme. Use this fact to determine if the sharable object 1011 * was produced by the GNU ld rather than the Solaris one, and to set 1012 * FLG_IF_GNUVER if so. This needs to be done before the symbols are 1013 * processed, since the answer determines whether we interpret the 1014 * symbols versions according to Solaris or GNU rules. 1015 */ 1016 /*ARGSUSED*/ 1017 static uintptr_t 1018 process_dynamic_isgnu(const char *name, Ifl_desc *ifl, Shdr *shdr, 1019 Elf_Scn *scn, Word ndx, int ident, Ofl_desc *ofl) 1020 { 1021 Dyn *dyn; 1022 Elf_Data *dp; 1023 1024 if (process_section(name, ifl, shdr, scn, ndx, ident, ofl) == S_ERROR) 1025 return (S_ERROR); 1026 1027 /* Get the .dynamic data */ 1028 dp = elf_getdata(scn, NULL); 1029 1030 for (dyn = (Dyn *)dp->d_buf; dyn->d_tag != DT_NULL; dyn++) { 1031 if (dyn->d_tag == DT_VERSYM) { 1032 ifl->ifl_flags |= FLG_IF_GNUVER; 1033 break; 1034 } 1035 } 1036 return (1); 1037 } 1038 1039 /* 1040 * Process a dynamic section. If we are processing an explicit shared object 1041 * then we need to determine if it has a recorded SONAME, if so, this name will 1042 * be recorded in the output file being generated as the NEEDED entry rather 1043 * than the shared objects filename itself. 1044 * If the mode of the link-edit indicates that no undefined symbols should 1045 * remain, then we also need to build up a list of any additional shared object 1046 * dependencies this object may have. In this case save any NEEDED entries 1047 * together with any associated run-path specifications. This information is 1048 * recorded on the `ofl_soneed' list and will be analyzed after all explicit 1049 * file processing has been completed (refer finish_libs()). 1050 */ 1051 static uintptr_t 1052 process_dynamic(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl) 1053 { 1054 Dyn *data, *dyn; 1055 char *str, *rpath = NULL; 1056 const char *soname, *needed; 1057 Sdf_desc *sdf; 1058 Listnode *lnp; 1059 1060 data = (Dyn *)isc->is_indata->d_buf; 1061 str = (char *)ifl->ifl_isdesc[isc->is_shdr->sh_link]->is_indata->d_buf; 1062 1063 /* 1064 * First loop through the dynamic section looking for a run path. 1065 */ 1066 if (ofl->ofl_flags & (FLG_OF_NOUNDEF | FLG_OF_SYMBOLIC)) { 1067 for (dyn = data; dyn->d_tag != DT_NULL; dyn++) { 1068 if ((dyn->d_tag != DT_RPATH) && 1069 (dyn->d_tag != DT_RUNPATH)) 1070 continue; 1071 if ((rpath = str + (size_t)dyn->d_un.d_val) == NULL) 1072 continue; 1073 break; 1074 } 1075 } 1076 1077 /* 1078 * Now look for any needed dependencies (which may use the rpath) 1079 * or a new SONAME. 1080 */ 1081 for (dyn = data; dyn->d_tag != DT_NULL; dyn++) { 1082 if (dyn->d_tag == DT_SONAME) { 1083 if ((soname = str + (size_t)dyn->d_un.d_val) == NULL) 1084 continue; 1085 1086 /* 1087 * Update the input file structure with this new name. 1088 */ 1089 ifl->ifl_soname = soname; 1090 1091 } else if ((dyn->d_tag == DT_NEEDED) || 1092 (dyn->d_tag == DT_USED)) { 1093 if (!(ofl->ofl_flags & 1094 (FLG_OF_NOUNDEF | FLG_OF_SYMBOLIC))) 1095 continue; 1096 if ((needed = str + (size_t)dyn->d_un.d_val) == NULL) 1097 continue; 1098 1099 /* 1100 * Determine if this needed entry is already recorded on 1101 * the shared object needed list, if not create a new 1102 * definition for later processing (see finish_libs()). 1103 */ 1104 needed = expand(ifl->ifl_name, needed, (char **)0); 1105 1106 if ((sdf = sdf_find(needed, &ofl->ofl_soneed)) == 0) { 1107 if ((sdf = sdf_add(needed, 1108 &ofl->ofl_soneed)) == (Sdf_desc *)S_ERROR) 1109 return (S_ERROR); 1110 sdf->sdf_rfile = ifl->ifl_name; 1111 } 1112 1113 /* 1114 * Record the runpath (Note that we take the first 1115 * runpath which is exactly what ld.so.1 would do during 1116 * its dependency processing). 1117 */ 1118 if (rpath && (sdf->sdf_rpath == 0)) 1119 sdf->sdf_rpath = rpath; 1120 1121 } else if (dyn->d_tag == DT_FLAGS_1) { 1122 if (dyn->d_un.d_val & (DF_1_INITFIRST | DF_1_INTERPOSE)) 1123 ifl->ifl_flags &= ~FLG_IF_LAZYLD; 1124 if (dyn->d_un.d_val & DF_1_DISPRELPND) 1125 ifl->ifl_flags |= FLG_IF_DISPPEND; 1126 if (dyn->d_un.d_val & DF_1_DISPRELDNE) 1127 ifl->ifl_flags |= FLG_IF_DISPDONE; 1128 if (dyn->d_un.d_val & DF_1_NODIRECT) 1129 ifl->ifl_flags |= FLG_IF_NODIRECT; 1130 1131 } else if ((dyn->d_tag == DT_AUDIT) && 1132 (ifl->ifl_flags & FLG_IF_NEEDED)) { 1133 /* 1134 * Record audit string as DT_DEPAUDIT. 1135 */ 1136 if ((ofl->ofl_depaudit = add_string(ofl->ofl_depaudit, 1137 (str + (size_t)dyn->d_un.d_val))) == 1138 (const char *)S_ERROR) 1139 return (S_ERROR); 1140 1141 } else if (dyn->d_tag == DT_SUNW_RTLDINF) { 1142 /* 1143 * If a library has the SUNW_RTLDINF .dynamic entry 1144 * then we must not permit lazyloading of this library. 1145 * This is because critical startup information (TLS 1146 * routines) are provided as part of these interfaces 1147 * and we must have them as part of process startup. 1148 */ 1149 ifl->ifl_flags &= ~FLG_IF_LAZYLD; 1150 } 1151 } 1152 1153 /* 1154 * Perform some SONAME sanity checks. 1155 */ 1156 if (ifl->ifl_flags & FLG_IF_NEEDED) { 1157 Ifl_desc * sifl; 1158 1159 /* 1160 * Determine if anyone else will cause the same SONAME to be 1161 * used (this is either caused by two different files having the 1162 * same SONAME, or by one file SONAME actually matching another 1163 * file basename (if no SONAME is specified within a shared 1164 * library its basename will be used)). Probably rare, but some 1165 * idiot will do it. 1166 */ 1167 for (LIST_TRAVERSE(&ofl->ofl_sos, lnp, sifl)) { 1168 if ((strcmp(ifl->ifl_soname, sifl->ifl_soname) == 0) && 1169 (ifl != sifl)) { 1170 const char *hint, *iflb, *siflb; 1171 1172 /* 1173 * Determine the basename of each file. Perhaps 1174 * there are multiple copies of the same file 1175 * being brought in using different -L search 1176 * paths, and if so give an extra hint in the 1177 * error message. 1178 */ 1179 iflb = strrchr(ifl->ifl_name, '/'); 1180 if (iflb == NULL) 1181 iflb = ifl->ifl_name; 1182 else 1183 iflb++; 1184 1185 siflb = strrchr(sifl->ifl_name, '/'); 1186 if (siflb == NULL) 1187 siflb = sifl->ifl_name; 1188 else 1189 siflb++; 1190 1191 if (strcmp(iflb, siflb) == 0) 1192 hint = MSG_INTL(MSG_REC_CNFLTHINT); 1193 else 1194 hint = MSG_ORIG(MSG_STR_EMPTY); 1195 1196 eprintf(ofl->ofl_lml, ERR_FATAL, 1197 MSG_INTL(MSG_REC_OBJCNFLT), sifl->ifl_name, 1198 ifl->ifl_name, sifl->ifl_soname, hint); 1199 ofl->ofl_flags |= FLG_OF_FATAL; 1200 return (0); 1201 } 1202 } 1203 1204 /* 1205 * If the SONAME is the same as the name the user wishes to 1206 * record when building a dynamic library (refer -h option), 1207 * we also have a name clash. 1208 */ 1209 if (ofl->ofl_soname && 1210 (strcmp(ofl->ofl_soname, ifl->ifl_soname) == 0)) { 1211 eprintf(ofl->ofl_lml, ERR_FATAL, 1212 MSG_INTL(MSG_REC_OPTCNFLT), ifl->ifl_name, 1213 ifl->ifl_soname); 1214 ofl->ofl_flags |= FLG_OF_FATAL; 1215 return (0); 1216 } 1217 } 1218 return (1); 1219 } 1220 1221 /* 1222 * Process a relocation entry. At this point all input sections from this 1223 * input file have been assigned an input section descriptor which is saved 1224 * in the `ifl_isdesc' array. 1225 */ 1226 static uintptr_t 1227 rel_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl) 1228 { 1229 Word rndx; 1230 Is_desc *risc; 1231 Os_desc *osp; 1232 Shdr *shdr = isc->is_shdr; 1233 Conv_inv_buf_t inv_buf; 1234 1235 /* 1236 * Make sure this is a valid relocation we can handle. 1237 */ 1238 if (shdr->sh_type != ld_targ.t_m.m_rel_sht_type) { 1239 eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_FIL_INVALSEC), 1240 ifl->ifl_name, isc->is_name, 1241 conv_sec_type(ifl->ifl_ehdr->e_machine, 1242 shdr->sh_type, 0, &inv_buf)); 1243 ofl->ofl_flags |= FLG_OF_FATAL; 1244 return (0); 1245 } 1246 1247 /* 1248 * From the relocation section header information determine which 1249 * section needs the actual relocation. Determine which output section 1250 * this input section has been assigned to and add to its relocation 1251 * list. Note that the relocation section may be null if it is not 1252 * required (ie. .debug, .stabs, etc). 1253 */ 1254 rndx = shdr->sh_info; 1255 if (rndx >= ifl->ifl_shnum) { 1256 /* 1257 * Broken input file. 1258 */ 1259 eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO), 1260 ifl->ifl_name, isc->is_name, EC_XWORD(rndx)); 1261 ofl->ofl_flags |= FLG_OF_FATAL; 1262 return (0); 1263 } 1264 if (rndx == 0) { 1265 if (list_appendc(&ofl->ofl_extrarels, isc) == 0) 1266 return (S_ERROR); 1267 } else if ((risc = ifl->ifl_isdesc[rndx]) != 0) { 1268 /* 1269 * Discard relocations if they are against a section 1270 * which has been discarded. 1271 */ 1272 if (risc->is_flags & FLG_IS_DISCARD) 1273 return (1); 1274 if ((osp = risc->is_osdesc) == 0) { 1275 if (risc->is_shdr->sh_type == SHT_SUNW_move) { 1276 /* 1277 * This section is processed later 1278 * in sunwmove_preprocess() and 1279 * reloc_init(). 1280 */ 1281 if (list_appendc(&ofl->ofl_mvrelisdescs, 1282 isc) == 0) 1283 return (S_ERROR); 1284 return (1); 1285 } 1286 eprintf(ofl->ofl_lml, ERR_FATAL, 1287 MSG_INTL(MSG_FIL_INVRELOC1), ifl->ifl_name, 1288 isc->is_name, risc->is_name); 1289 return (0); 1290 } 1291 if (list_appendc(&osp->os_relisdescs, isc) == 0) 1292 return (S_ERROR); 1293 } 1294 return (1); 1295 } 1296 1297 /* 1298 * SHF_EXCLUDE flags is set for this section. 1299 */ 1300 static uintptr_t 1301 process_exclude(const char *name, Ifl_desc *ifl, Shdr *shdr, Elf_Scn *scn, 1302 Word ndx, Ofl_desc *ofl) 1303 { 1304 /* 1305 * Sections SHT_SYMTAB and SHT_DYNDYM, even if SHF_EXCLUDE is on, might 1306 * be needed for ld processing. These sections need to be in the 1307 * internal table. Later it will be determined whether they can be 1308 * eliminated or not. 1309 */ 1310 if (shdr->sh_type == SHT_SYMTAB || shdr->sh_type == SHT_DYNSYM) 1311 return (0); 1312 1313 /* 1314 * Other checks 1315 */ 1316 if (shdr->sh_flags & SHF_ALLOC) { 1317 /* 1318 * A conflict, issue an warning message, and ignore the section. 1319 */ 1320 eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_FIL_EXCLUDE), 1321 ifl->ifl_name, name); 1322 return (0); 1323 } 1324 1325 /* 1326 * This sections is not going to the output file. 1327 */ 1328 return (process_section(name, ifl, shdr, scn, ndx, 0, ofl)); 1329 } 1330 1331 #if defined(_ELF64) 1332 1333 static uintptr_t 1334 process_amd64_unwind(const char *name, Ifl_desc *ifl, Shdr *shdr, 1335 Elf_Scn *scn, Word ndx, int ident, Ofl_desc *ofl) 1336 { 1337 Os_desc *osp, *eosp; 1338 Is_desc *isp; 1339 Listnode *lnp; 1340 1341 if (process_section(name, ifl, shdr, scn, ndx, ident, ofl) == S_ERROR) 1342 return (S_ERROR); 1343 1344 /* 1345 * When producing a relocatable object - just collect the sections. 1346 */ 1347 if (ofl->ofl_flags & FLG_OF_RELOBJ) 1348 return (1); 1349 1350 /* 1351 * If producing a executable or shared library, keep track of all the 1352 * output UNWIND sections to allow the creation of the appropriate 1353 * frame_hdr information. 1354 * 1355 * If the section hasn't been placed in the output file, then there's 1356 * nothing for us to do. 1357 */ 1358 if (((isp = ifl->ifl_isdesc[ndx]) == 0) || 1359 ((osp = isp->is_osdesc) == 0)) 1360 return (1); 1361 1362 /* 1363 * Check to see if this output section is already on the list, and if 1364 * not, add it. 1365 */ 1366 for (LIST_TRAVERSE(&ofl->ofl_unwind, lnp, eosp)) 1367 if (osp == eosp) 1368 return (1); 1369 1370 if (list_appendc(&ofl->ofl_unwind, osp) == 0) 1371 return (S_ERROR); 1372 1373 return (1); 1374 } 1375 1376 #endif 1377 1378 /* 1379 * Section processing state table. `Initial' describes the required initial 1380 * procedure to be called (if any), `Final' describes the final processing 1381 * procedure (ie. things that can only be done when all required sections 1382 * have been collected). 1383 */ 1384 static uintptr_t (*Initial[SHT_NUM][2])() = { 1385 1386 /* ET_REL ET_DYN */ 1387 1388 /* SHT_NULL */ invalid_section, invalid_section, 1389 /* SHT_PROGBITS */ process_progbits, process_progbits, 1390 /* SHT_SYMTAB */ process_input, process_input, 1391 /* SHT_STRTAB */ process_strtab, process_strtab, 1392 /* SHT_RELA */ process_reloc, process_reloc, 1393 /* SHT_HASH */ invalid_section, NULL, 1394 /* SHT_DYNAMIC */ process_rel_dynamic, process_dynamic_isgnu, 1395 /* SHT_NOTE */ process_section, NULL, 1396 /* SHT_NOBITS */ process_nobits, process_nobits, 1397 /* SHT_REL */ process_reloc, process_reloc, 1398 /* SHT_SHLIB */ process_section, invalid_section, 1399 /* SHT_DYNSYM */ invalid_section, process_input, 1400 /* SHT_UNKNOWN12 */ process_progbits, process_progbits, 1401 /* SHT_UNKNOWN13 */ process_progbits, process_progbits, 1402 /* SHT_INIT_ARRAY */ process_array, NULL, 1403 /* SHT_FINI_ARRAY */ process_array, NULL, 1404 /* SHT_PREINIT_ARRAY */ process_array, NULL, 1405 /* SHT_GROUP */ process_section, invalid_section, 1406 /* SHT_SYMTAB_SHNDX */ process_sym_shndx, NULL 1407 }; 1408 1409 static uintptr_t (*Final[SHT_NUM][2])() = { 1410 1411 /* SHT_NULL */ NULL, NULL, 1412 /* SHT_PROGBITS */ NULL, NULL, 1413 /* SHT_SYMTAB */ ld_sym_process, ld_sym_process, 1414 /* SHT_STRTAB */ NULL, NULL, 1415 /* SHT_RELA */ rel_process, NULL, 1416 /* SHT_HASH */ NULL, NULL, 1417 /* SHT_DYNAMIC */ NULL, process_dynamic, 1418 /* SHT_NOTE */ NULL, NULL, 1419 /* SHT_NOBITS */ NULL, NULL, 1420 /* SHT_REL */ rel_process, NULL, 1421 /* SHT_SHLIB */ NULL, NULL, 1422 /* SHT_DYNSYM */ NULL, ld_sym_process, 1423 /* SHT_UNKNOWN12 */ NULL, NULL, 1424 /* SHT_UNKNOWN13 */ NULL, NULL, 1425 /* SHT_INIT_ARRAY */ NULL, NULL, 1426 /* SHT_FINI_ARRAY */ NULL, NULL, 1427 /* SHT_PREINIT_ARRAY */ NULL, NULL, 1428 /* SHT_GROUP */ NULL, NULL, 1429 /* SHT_SYMTAB_SHNDX */ sym_shndx_process, NULL 1430 }; 1431 1432 #define MAXNDXSIZE 10 1433 1434 /* 1435 * Process an elf file. Each section is compared against the section state 1436 * table to determine whether it should be processed (saved), ignored, or 1437 * is invalid for the type of input file being processed. 1438 */ 1439 static uintptr_t 1440 process_elf(Ifl_desc *ifl, Elf *elf, Ofl_desc *ofl) 1441 { 1442 Elf_Scn *scn; 1443 Shdr *shdr; 1444 Word ndx, sndx; 1445 char *str, *name, _name[MAXNDXSIZE]; 1446 Word row, column; 1447 int ident; 1448 uintptr_t error; 1449 Is_desc *vdfisp, *vndisp, *vsyisp, *sifisp, *capisp; 1450 Sdf_desc *sdf; 1451 Word ordered_shndx = 0; /* index to first ordered section */ 1452 Word ordered_cnt = 0; 1453 1454 /* 1455 * First process the .shstrtab section so that later sections can 1456 * reference their name. 1457 */ 1458 ld_sup_file(ofl, ifl->ifl_name, elf_kind(elf), ifl->ifl_flags, elf); 1459 1460 sndx = ifl->ifl_shstrndx; 1461 if ((scn = elf_getscn(elf, (size_t)sndx)) == NULL) { 1462 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETSCN), 1463 ifl->ifl_name); 1464 ofl->ofl_flags |= FLG_OF_FATAL; 1465 return (0); 1466 } 1467 if ((shdr = elf_getshdr(scn)) == NULL) { 1468 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_GETSHDR), 1469 ifl->ifl_name); 1470 ofl->ofl_flags |= FLG_OF_FATAL; 1471 return (0); 1472 } 1473 if ((name = elf_strptr(elf, (size_t)sndx, (size_t)shdr->sh_name)) == 1474 NULL) { 1475 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_STRPTR), 1476 ifl->ifl_name); 1477 ofl->ofl_flags |= FLG_OF_FATAL; 1478 return (0); 1479 } 1480 1481 if (ld_sup_input_section(ofl, ifl, name, &shdr, sndx, scn, 1482 elf) == S_ERROR) 1483 return (S_ERROR); 1484 1485 /* 1486 * Reset the name since the shdr->sh_name could have been changed as 1487 * part of ld_sup_input_section(). If there is no name, fabricate one 1488 * using the section index. 1489 */ 1490 if (shdr->sh_name == 0) { 1491 (void) snprintf(_name, MAXNDXSIZE, MSG_ORIG(MSG_FMT_INDEX), 1492 EC_XWORD(sndx)); 1493 if ((name = libld_malloc(strlen(_name) + 1)) == 0) 1494 return (S_ERROR); 1495 (void) strcpy(name, _name); 1496 1497 } else if ((name = elf_strptr(elf, (size_t)sndx, 1498 (size_t)shdr->sh_name)) == NULL) { 1499 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_STRPTR), 1500 ifl->ifl_name); 1501 ofl->ofl_flags |= FLG_OF_FATAL; 1502 return (0); 1503 } 1504 1505 error = process_strtab(name, ifl, shdr, scn, sndx, FALSE, ofl); 1506 if ((error == 0) || (error == S_ERROR)) 1507 return (error); 1508 str = ifl->ifl_isdesc[sndx]->is_indata->d_buf; 1509 1510 /* 1511 * Determine the state table column from the input file type. Note, 1512 * shared library sections are not added to the output section list. 1513 */ 1514 if (ifl->ifl_ehdr->e_type == ET_DYN) { 1515 column = 1; 1516 ofl->ofl_soscnt++; 1517 ident = ld_targ.t_id.id_null; 1518 } else { 1519 column = 0; 1520 ofl->ofl_objscnt++; 1521 ident = ld_targ.t_id.id_unknown; 1522 } 1523 1524 DBG_CALL(Dbg_file_generic(ofl->ofl_lml, ifl)); 1525 ndx = 0; 1526 vdfisp = vndisp = vsyisp = sifisp = capisp = 0; 1527 scn = NULL; 1528 while (scn = elf_nextscn(elf, scn)) { 1529 ndx++; 1530 /* 1531 * As we've already processed the .shstrtab don't do it again. 1532 */ 1533 if (ndx == sndx) 1534 continue; 1535 1536 if ((shdr = elf_getshdr(scn)) == NULL) { 1537 eprintf(ofl->ofl_lml, ERR_ELF, 1538 MSG_INTL(MSG_ELF_GETSHDR), ifl->ifl_name); 1539 ofl->ofl_flags |= FLG_OF_FATAL; 1540 return (0); 1541 } 1542 name = str + (size_t)(shdr->sh_name); 1543 1544 if (ld_sup_input_section(ofl, ifl, name, &shdr, ndx, scn, 1545 elf) == S_ERROR) 1546 return (S_ERROR); 1547 1548 /* 1549 * Reset the name since the shdr->sh_name could have been 1550 * changed as part of ld_sup_input_section(). If there is no 1551 * name, fabricate one using the section index. 1552 */ 1553 if (shdr->sh_name == 0) { 1554 (void) snprintf(_name, MAXNDXSIZE, 1555 MSG_ORIG(MSG_FMT_INDEX), EC_XWORD(ndx)); 1556 if ((name = libld_malloc(strlen(_name) + 1)) == 0) 1557 return (S_ERROR); 1558 (void) strcpy(name, _name); 1559 } else 1560 name = str + (size_t)(shdr->sh_name); 1561 1562 row = shdr->sh_type; 1563 1564 /* 1565 * If the section has the SHF_EXCLUDE flag on, and we're not 1566 * generating a relocatable object, exclude the section. 1567 */ 1568 if (((shdr->sh_flags & SHF_EXCLUDE) != 0) && 1569 ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) { 1570 if ((error = process_exclude(name, ifl, shdr, scn, 1571 ndx, ofl)) == S_ERROR) 1572 return (S_ERROR); 1573 if (error == 1) 1574 continue; 1575 } 1576 1577 /* 1578 * If this is a standard section type process it via the 1579 * appropriate action routine. 1580 */ 1581 if (row < SHT_NUM) { 1582 if (Initial[row][column] != NULL) { 1583 if (Initial[row][column](name, ifl, shdr, scn, 1584 ndx, ident, ofl) == S_ERROR) 1585 return (S_ERROR); 1586 } 1587 } else { 1588 /* 1589 * If this section is below SHT_LOSUNW then we don't 1590 * really know what to do with it, issue a warning 1591 * message but do the basic section processing anyway. 1592 */ 1593 if (row < (Word)SHT_LOSUNW) { 1594 Conv_inv_buf_t inv_buf; 1595 1596 eprintf(ofl->ofl_lml, ERR_WARNING, 1597 MSG_INTL(MSG_FIL_INVALSEC), ifl->ifl_name, 1598 name, 1599 conv_sec_type(ifl->ifl_ehdr->e_machine, 1600 shdr->sh_type, 0, &inv_buf)); 1601 } 1602 1603 /* 1604 * Handle sections greater than SHT_LOSUNW. 1605 */ 1606 switch (row) { 1607 case SHT_SUNW_dof: 1608 if (process_section(name, ifl, shdr, scn, 1609 ndx, ident, ofl) == S_ERROR) 1610 return (S_ERROR); 1611 break; 1612 case SHT_SUNW_cap: 1613 if (process_section(name, ifl, shdr, scn, 1614 ndx, ld_targ.t_id.id_null, ofl) == S_ERROR) 1615 return (S_ERROR); 1616 capisp = ifl->ifl_isdesc[ndx]; 1617 break; 1618 case SHT_SUNW_DEBUGSTR: 1619 case SHT_SUNW_DEBUG: 1620 if (process_debug(name, ifl, shdr, scn, 1621 ndx, ident, ofl) == S_ERROR) 1622 return (S_ERROR); 1623 break; 1624 case SHT_SUNW_move: 1625 if (process_section(name, ifl, shdr, scn, 1626 ndx, ld_targ.t_id.id_null, ofl) == S_ERROR) 1627 return (S_ERROR); 1628 break; 1629 case SHT_SUNW_syminfo: 1630 if (process_section(name, ifl, shdr, scn, 1631 ndx, ld_targ.t_id.id_null, ofl) == S_ERROR) 1632 return (S_ERROR); 1633 sifisp = ifl->ifl_isdesc[ndx]; 1634 break; 1635 case SHT_SUNW_ANNOTATE: 1636 case SHT_SUNW_COMDAT: 1637 if (process_progbits(name, ifl, shdr, scn, 1638 ndx, ident, ofl) == S_ERROR) 1639 return (S_ERROR); 1640 break; 1641 case SHT_SUNW_verdef: 1642 if (process_section(name, ifl, shdr, scn, 1643 ndx, ld_targ.t_id.id_null, ofl) == S_ERROR) 1644 return (S_ERROR); 1645 vdfisp = ifl->ifl_isdesc[ndx]; 1646 break; 1647 case SHT_SUNW_verneed: 1648 if (process_section(name, ifl, shdr, scn, 1649 ndx, ld_targ.t_id.id_null, ofl) == S_ERROR) 1650 return (S_ERROR); 1651 vndisp = ifl->ifl_isdesc[ndx]; 1652 break; 1653 case SHT_SUNW_versym: 1654 if (process_section(name, ifl, shdr, scn, 1655 ndx, ld_targ.t_id.id_null, ofl) == S_ERROR) 1656 return (S_ERROR); 1657 vsyisp = ifl->ifl_isdesc[ndx]; 1658 break; 1659 case SHT_SPARC_GOTDATA: 1660 /* 1661 * SHT_SPARC_GOTDATA (0x70000000) is in the 1662 * SHT_LOPROC - SHT_HIPROC range reserved 1663 * for processor-specific semantics. It is 1664 * only meaningful for sparc targets. 1665 */ 1666 if (ld_targ.t_m.m_mach != 1667 LD_TARG_BYCLASS(EM_SPARC, EM_SPARCV9)) 1668 goto do_default; 1669 if (process_section(name, ifl, shdr, scn, 1670 ndx, ld_targ.t_id.id_gotdata, ofl) == 1671 S_ERROR) 1672 return (S_ERROR); 1673 break; 1674 #if defined(_ELF64) 1675 case SHT_AMD64_UNWIND: 1676 /* 1677 * SHT_AMD64_UNWIND (0x70000001) is in the 1678 * SHT_LOPROC - SHT_HIPROC range reserved 1679 * for processor-specific semantics. It is 1680 * only meaningful for amd64 targets. 1681 */ 1682 if (ld_targ.t_m.m_mach != EM_AMD64) 1683 goto do_default; 1684 /* 1685 * Target is x86, so this really is 1686 * SHT_AMD64_UNWIND 1687 */ 1688 if (column == 0) { 1689 /* 1690 * column == ET_REL 1691 */ 1692 if (process_amd64_unwind(name, ifl, 1693 shdr, scn, ndx, 1694 ld_targ.t_id.id_unwind, ofl) == 1695 S_ERROR) 1696 return (S_ERROR); 1697 } 1698 break; 1699 #endif 1700 default: 1701 do_default: 1702 if (ident != ld_targ.t_id.id_null) 1703 ident = ld_targ.t_id.id_user; 1704 if (process_section(name, ifl, shdr, scn, 1705 ndx, ident, ofl) == S_ERROR) 1706 return (S_ERROR); 1707 break; 1708 } 1709 } 1710 1711 /* 1712 * If we have any sections that require ORDERED processing, 1713 * remember the index of the first ordered section. This let's 1714 * us know if we need an ORDERED place_section pass, and if so, 1715 * where to start. 1716 */ 1717 if (ifl->ifl_isdesc[ndx] && 1718 (ifl->ifl_isdesc[ndx]->is_shdr->sh_flags & ALL_SHF_ORDER)) { 1719 ordered_cnt++; 1720 if (ordered_shndx == 0) 1721 ordered_shndx = ndx; 1722 } 1723 } 1724 1725 /* 1726 * Now that all of sections have been placed, scan through any sections 1727 * which have special ordering requirements and place them now. 1728 */ 1729 if (ordered_shndx) { 1730 Word cnt; 1731 1732 for (ndx = ordered_shndx, cnt = 0; 1733 (ndx < ifl->ifl_shnum) && (cnt < ordered_cnt); ndx++) { 1734 Is_desc *isp; 1735 /* LINTED */ 1736 Os_desc *osp; 1737 1738 if (((isp = ifl->ifl_isdesc[ndx]) == 0) || 1739 ((isp->is_shdr->sh_flags & ALL_SHF_ORDER) == 0)) 1740 continue; 1741 1742 /* 1743 * If this is an ordered section, process it. 1744 */ 1745 cnt++; 1746 if ((osp = (Os_desc *)ld_process_ordered(ifl, ofl, ndx, 1747 ifl->ifl_shnum)) == (Os_desc *)S_ERROR) 1748 return (S_ERROR); 1749 1750 #if defined(_ELF64) 1751 /* 1752 * If this section is 'ordered' then it was not 1753 * caught in the previous 'place_section' operation. 1754 * 1755 * So - now that we have a OSP section for 1756 * the unwind info - record it. 1757 */ 1758 if (osp && 1759 (osp->os_shdr->sh_type == SHT_AMD64_UNWIND) && 1760 (ld_targ.t_uw.uw_append_unwind != NULL) && 1761 ((*ld_targ.t_uw.uw_append_unwind)(osp, ofl) == 1762 S_ERROR)) 1763 return (S_ERROR); 1764 #endif 1765 } 1766 } 1767 1768 /* 1769 * If this is an explicit shared object determine if the user has 1770 * specified a control definition. This descriptor may specify which 1771 * version definitions can be used from this object (it may also update 1772 * the dependency to USED and supply an alternative SONAME). 1773 */ 1774 sdf = 0; 1775 if (column && (ifl->ifl_flags & FLG_IF_NEEDED)) { 1776 const char *base; 1777 1778 /* 1779 * Use the basename of the input file (typically this is the 1780 * compilation environment name, ie. libfoo.so). 1781 */ 1782 if ((base = strrchr(ifl->ifl_name, '/')) == NULL) 1783 base = ifl->ifl_name; 1784 else 1785 base++; 1786 1787 if ((sdf = sdf_find(base, &ofl->ofl_socntl)) != 0) { 1788 sdf->sdf_file = ifl; 1789 ifl->ifl_sdfdesc = sdf; 1790 } 1791 } 1792 1793 /* 1794 * Process any hardware/software capabilities sections. Only propagate 1795 * capabilities for input relocatable objects. If the object doesn't 1796 * contain any capabilities, any capability state that has already been 1797 * gathered will prevail. 1798 */ 1799 if (capisp && (ifl->ifl_ehdr->e_type == ET_REL)) 1800 process_cap(ifl, capisp, ofl); 1801 1802 /* 1803 * Process any version dependencies. These will establish shared object 1804 * `needed' entries in the same manner as will be generated from the 1805 * .dynamic's NEEDED entries. 1806 */ 1807 if (vndisp && (ofl->ofl_flags & (FLG_OF_NOUNDEF | FLG_OF_SYMBOLIC))) 1808 if (ld_vers_need_process(vndisp, ifl, ofl) == S_ERROR) 1809 return (S_ERROR); 1810 1811 /* 1812 * Before processing any symbol resolution or relocations process any 1813 * version sections. 1814 */ 1815 if (vsyisp) 1816 (void) ld_vers_sym_process(ofl->ofl_lml, vsyisp, ifl); 1817 1818 if (ifl->ifl_versym && 1819 (vdfisp || (sdf && (sdf->sdf_flags & FLG_SDF_SELECT)))) 1820 if (ld_vers_def_process(vdfisp, ifl, ofl) == S_ERROR) 1821 return (S_ERROR); 1822 1823 /* 1824 * Having collected the appropriate sections carry out any additional 1825 * processing if necessary. 1826 */ 1827 for (ndx = 0; ndx < ifl->ifl_shnum; ndx++) { 1828 Is_desc * isp; 1829 1830 if ((isp = ifl->ifl_isdesc[ndx]) == 0) 1831 continue; 1832 row = isp->is_shdr->sh_type; 1833 1834 if ((isp->is_flags & FLG_IS_DISCARD) == 0) 1835 ld_sup_section(ofl, isp->is_name, isp->is_shdr, ndx, 1836 isp->is_indata, elf); 1837 1838 /* 1839 * If this is a ST_SUNW_move section from a 1840 * a relocatable file, keep the input section. 1841 */ 1842 if ((row == SHT_SUNW_move) && (column == 0)) { 1843 if (list_appendc(&(ofl->ofl_ismove), isp) == 0) 1844 return (S_ERROR); 1845 } 1846 1847 /* 1848 * If this is a standard section type process it via the 1849 * appropriate action routine. 1850 */ 1851 if (row < SHT_NUM) { 1852 if (Final[row][column] != NULL) 1853 if (Final[row][column](isp, ifl, ofl) == 1854 S_ERROR) 1855 return (S_ERROR); 1856 } 1857 } 1858 1859 /* 1860 * After processing any symbol resolution, and if this dependency 1861 * indicates it contains symbols that can't be directly bound to, 1862 * set the symbols appropriately. 1863 */ 1864 if (sifisp && ((ifl->ifl_flags & (FLG_IF_NEEDED | FLG_IF_NODIRECT)) == 1865 (FLG_IF_NEEDED | FLG_IF_NODIRECT))) 1866 (void) ld_sym_nodirect(sifisp, ifl, ofl); 1867 1868 return (1); 1869 } 1870 1871 /* 1872 * Process the current input file. There are basically three types of files 1873 * that come through here: 1874 * 1875 * o files explicitly defined on the command line (ie. foo.o or bar.so), 1876 * in this case only the `name' field is valid. 1877 * 1878 * o libraries determined from the -l command line option (ie. -lbar), 1879 * in this case the `soname' field contains the basename of the located 1880 * file. 1881 * 1882 * Any shared object specified via the above two conventions must be recorded 1883 * as a needed dependency. 1884 * 1885 * o libraries specified as dependencies of those libraries already obtained 1886 * via the command line (ie. bar.so has a DT_NEEDED entry of fred.so.1), 1887 * in this case the `soname' field contains either a full pathname (if the 1888 * needed entry contained a `/'), or the basename of the located file. 1889 * These libraries are processed to verify symbol binding but are not 1890 * recorded as dependencies of the output file being generated. 1891 */ 1892 Ifl_desc * 1893 ld_process_ifl(const char *name, const char *soname, int fd, Elf *elf, 1894 Word flags, Ofl_desc * ofl, Rej_desc * rej) 1895 { 1896 Ifl_desc *ifl; 1897 Ehdr *ehdr; 1898 Listnode *lnp; 1899 uintptr_t error = 0; 1900 struct stat status; 1901 Ar_desc *adp; 1902 Rej_desc _rej; 1903 1904 /* 1905 * If this file was not extracted from an archive obtain its device 1906 * information. This will be used to determine if the file has already 1907 * been processed (rather than simply comparing filenames, the device 1908 * information provides a quicker comparison and detects linked files). 1909 */ 1910 if (!(flags & FLG_IF_EXTRACT)) 1911 (void) fstat(fd, &status); 1912 else { 1913 status.st_dev = 0; 1914 status.st_ino = 0; 1915 } 1916 1917 switch (elf_kind(elf)) { 1918 case ELF_K_AR: 1919 /* 1920 * Determine if we've already come across this archive file. 1921 */ 1922 if (!(flags & FLG_IF_EXTRACT)) { 1923 for (LIST_TRAVERSE(&ofl->ofl_ars, lnp, adp)) { 1924 if ((adp->ad_stdev != status.st_dev) || 1925 (adp->ad_stino != status.st_ino)) 1926 continue; 1927 1928 /* 1929 * We've seen this file before so reuse the 1930 * original archive descriptor and discard the 1931 * new elf descriptor. 1932 */ 1933 DBG_CALL(Dbg_file_reuse(ofl->ofl_lml, name, 1934 adp->ad_name)); 1935 (void) elf_end(elf); 1936 return ((Ifl_desc *)ld_process_archive(name, fd, 1937 adp, ofl)); 1938 } 1939 } 1940 1941 /* 1942 * As we haven't processed this file before establish a new 1943 * archive descriptor. 1944 */ 1945 adp = ld_ar_setup(name, elf, ofl); 1946 if ((adp == 0) || (adp == (Ar_desc *)S_ERROR)) 1947 return ((Ifl_desc *)adp); 1948 adp->ad_stdev = status.st_dev; 1949 adp->ad_stino = status.st_ino; 1950 1951 ld_sup_file(ofl, name, ELF_K_AR, flags, elf); 1952 1953 return ((Ifl_desc *)ld_process_archive(name, fd, adp, ofl)); 1954 1955 case ELF_K_ELF: 1956 /* 1957 * Obtain the elf header so that we can determine what type of 1958 * elf ELF_K_ELF file this is. 1959 */ 1960 if ((ehdr = elf_getehdr(elf)) == NULL) { 1961 int _class = gelf_getclass(elf); 1962 1963 /* 1964 * Failure could occur for a number of reasons at this 1965 * point. Typically the files class is incorrect (ie. 1966 * user is building 64-bit but managed to pint at 32-bit 1967 * libraries). However any number of elf errors can 1968 * also occur, such as from a truncated or corrupt file. 1969 * Here we try and get the best error message possible. 1970 */ 1971 if (ld_targ.t_m.m_class != _class) { 1972 _rej.rej_type = SGS_REJ_CLASS; 1973 _rej.rej_info = (uint_t)_class; 1974 } else { 1975 _rej.rej_type = SGS_REJ_STR; 1976 _rej.rej_str = elf_errmsg(-1); 1977 } 1978 _rej.rej_name = name; 1979 DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej, 1980 ld_targ.t_m.m_mach)); 1981 if (rej->rej_type == 0) { 1982 *rej = _rej; 1983 rej->rej_name = strdup(_rej.rej_name); 1984 } 1985 return (0); 1986 } 1987 1988 /* 1989 * Determine if we've already come across this file. 1990 */ 1991 if (!(flags & FLG_IF_EXTRACT)) { 1992 List * lst; 1993 1994 if (ehdr->e_type == ET_REL) 1995 lst = &ofl->ofl_objs; 1996 else 1997 lst = &ofl->ofl_sos; 1998 1999 /* 2000 * Traverse the appropriate file list and determine if 2001 * a dev/inode match is found. 2002 */ 2003 for (LIST_TRAVERSE(lst, lnp, ifl)) { 2004 /* 2005 * Ifl_desc generated via -Nneed, therefore no 2006 * actual file behind it. 2007 */ 2008 if (ifl->ifl_flags & FLG_IF_NEEDSTR) 2009 continue; 2010 2011 if ((ifl->ifl_stino != status.st_ino) || 2012 (ifl->ifl_stdev != status.st_dev)) 2013 continue; 2014 2015 /* 2016 * Disregard (skip) this image. 2017 */ 2018 DBG_CALL(Dbg_file_skip(ofl->ofl_lml, 2019 ifl->ifl_name, name)); 2020 (void) elf_end(elf); 2021 2022 /* 2023 * If the file was explicitly defined on the 2024 * command line (this is always the case for 2025 * relocatable objects, and is true for shared 2026 * objects when they weren't specified via -l or 2027 * were dragged in as an implicit dependency), 2028 * then warn the user. 2029 */ 2030 if ((flags & FLG_IF_CMDLINE) || 2031 (ifl->ifl_flags & FLG_IF_CMDLINE)) { 2032 const char *errmsg; 2033 2034 /* 2035 * Determine whether this is the same 2036 * file name as originally encountered 2037 * so as to provide the most 2038 * descriptive diagnostic. 2039 */ 2040 errmsg = 2041 (strcmp(name, ifl->ifl_name) == 0) ? 2042 MSG_INTL(MSG_FIL_MULINC_1) : 2043 MSG_INTL(MSG_FIL_MULINC_2); 2044 eprintf(ofl->ofl_lml, ERR_WARNING, 2045 errmsg, name, ifl->ifl_name); 2046 } 2047 return (ifl); 2048 } 2049 } 2050 2051 /* 2052 * At this point, we know we need the file. Establish an input 2053 * file descriptor and continue processing. 2054 */ 2055 ifl = ifl_setup(name, ehdr, elf, flags, ofl, rej); 2056 if ((ifl == 0) || (ifl == (Ifl_desc *)S_ERROR)) 2057 return (ifl); 2058 ifl->ifl_stdev = status.st_dev; 2059 ifl->ifl_stino = status.st_ino; 2060 2061 /* 2062 * If -zignore is in effect, mark this file as a potential 2063 * candidate (the files use isn't actually determined until 2064 * symbol resolution and relocation processing are completed). 2065 */ 2066 if (ofl->ofl_flags1 & FLG_OF1_IGNORE) 2067 ifl->ifl_flags |= FLG_IF_IGNORE; 2068 2069 switch (ehdr->e_type) { 2070 case ET_REL: 2071 (*ld_targ.t_mr.mr_mach_eflags)(ehdr, ofl); 2072 error = process_elf(ifl, elf, ofl); 2073 break; 2074 case ET_DYN: 2075 if ((ofl->ofl_flags & FLG_OF_STATIC) || 2076 !(ofl->ofl_flags & FLG_OF_DYNLIBS)) { 2077 eprintf(ofl->ofl_lml, ERR_FATAL, 2078 MSG_INTL(MSG_FIL_SOINSTAT), name); 2079 ofl->ofl_flags |= FLG_OF_FATAL; 2080 return (0); 2081 } 2082 2083 /* 2084 * Record any additional shared object information. 2085 * If no soname is specified (eg. this file was 2086 * derived from a explicit filename declaration on the 2087 * command line, ie. bar.so) use the pathname. 2088 * This entry may be overridden if the files dynamic 2089 * section specifies an DT_SONAME value. 2090 */ 2091 if (soname == NULL) 2092 ifl->ifl_soname = ifl->ifl_name; 2093 else 2094 ifl->ifl_soname = soname; 2095 2096 /* 2097 * If direct bindings, lazy loading, or group 2098 * permissions need to be established, mark this object. 2099 */ 2100 if (ofl->ofl_flags1 & FLG_OF1_ZDIRECT) 2101 ifl->ifl_flags |= FLG_IF_DIRECT; 2102 if (ofl->ofl_flags1 & FLG_OF1_LAZYLD) 2103 ifl->ifl_flags |= FLG_IF_LAZYLD; 2104 if (ofl->ofl_flags1 & FLG_OF1_GRPPRM) 2105 ifl->ifl_flags |= FLG_IF_GRPPRM; 2106 error = process_elf(ifl, elf, ofl); 2107 2108 /* 2109 * At this point we know if this file will be 2110 * lazyloaded, or whether bindings to it must be direct. 2111 * In either case, a syminfo section is required. 2112 */ 2113 if (ifl->ifl_flags & (FLG_IF_LAZYLD | FLG_IF_DIRECT)) 2114 ofl->ofl_flags |= FLG_OF_SYMINFO; 2115 2116 break; 2117 default: 2118 (void) elf_errno(); 2119 _rej.rej_type = SGS_REJ_UNKFILE; 2120 _rej.rej_name = name; 2121 DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej, 2122 ld_targ.t_m.m_mach)); 2123 if (rej->rej_type == 0) { 2124 *rej = _rej; 2125 rej->rej_name = strdup(_rej.rej_name); 2126 } 2127 return (0); 2128 } 2129 break; 2130 default: 2131 (void) elf_errno(); 2132 _rej.rej_type = SGS_REJ_UNKFILE; 2133 _rej.rej_name = name; 2134 DBG_CALL(Dbg_file_rejected(ofl->ofl_lml, &_rej, 2135 ld_targ.t_m.m_mach)); 2136 if (rej->rej_type == 0) { 2137 *rej = _rej; 2138 rej->rej_name = strdup(_rej.rej_name); 2139 } 2140 return (0); 2141 } 2142 if ((error == 0) || (error == S_ERROR)) 2143 return ((Ifl_desc *)error); 2144 else 2145 return (ifl); 2146 } 2147 2148 /* 2149 * Having successfully opened a file, set up the necessary elf structures to 2150 * process it further. This small section of processing is slightly different 2151 * from the elf initialization required to process a relocatable object from an 2152 * archive (see libs.c: ld_process_archive()). 2153 */ 2154 Ifl_desc * 2155 ld_process_open(const char *opath, const char *ofile, int *fd, Ofl_desc *ofl, 2156 Word flags, Rej_desc *rej) 2157 { 2158 Elf *elf; 2159 const char *npath = opath; 2160 const char *nfile = ofile; 2161 2162 if ((elf = elf_begin(*fd, ELF_C_READ, NULL)) == NULL) { 2163 eprintf(ofl->ofl_lml, ERR_ELF, MSG_INTL(MSG_ELF_BEGIN), npath); 2164 ofl->ofl_flags |= FLG_OF_FATAL; 2165 return (0); 2166 } 2167 2168 /* 2169 * Determine whether the support library wishes to process this open. 2170 * The support library may return: 2171 * . a different ELF descriptor (in which case they should have 2172 * closed the original) 2173 * . a different file descriptor (in which case they should have 2174 * closed the original) 2175 * . a different path and file name (presumably associated with 2176 * a different file descriptor) 2177 * 2178 * A file descriptor of -1, or and ELF descriptor of zero indicates 2179 * the file should be ignored. 2180 */ 2181 ld_sup_open(ofl, &npath, &nfile, fd, flags, &elf, NULL, 0, 2182 elf_kind(elf)); 2183 2184 if ((*fd == -1) || (elf == NULL)) 2185 return (0); 2186 2187 return (ld_process_ifl(npath, nfile, *fd, elf, flags, ofl, rej)); 2188 } 2189 2190 /* 2191 * Process a required library (i.e. the dependency of a shared object). 2192 * Combine the directory and filename, check the resultant path size, and try 2193 * opening the pathname. 2194 */ 2195 static Ifl_desc * 2196 process_req_lib(Sdf_desc *sdf, const char *dir, const char *file, 2197 Ofl_desc * ofl, Rej_desc * rej) 2198 { 2199 size_t dlen, plen; 2200 int fd; 2201 char path[PATH_MAX]; 2202 const char *_dir = dir; 2203 2204 /* 2205 * Determine the sizes of the directory and filename to insure we don't 2206 * exceed our buffer. 2207 */ 2208 if ((dlen = strlen(dir)) == 0) { 2209 _dir = MSG_ORIG(MSG_STR_DOT); 2210 dlen = 1; 2211 } 2212 dlen++; 2213 plen = dlen + strlen(file) + 1; 2214 if (plen > PATH_MAX) { 2215 eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_FIL_PTHTOLONG), 2216 _dir, file); 2217 ofl->ofl_flags |= FLG_OF_FATAL; 2218 return (0); 2219 } 2220 2221 /* 2222 * Build the entire pathname and try and open the file. 2223 */ 2224 (void) strcpy(path, _dir); 2225 (void) strcat(path, MSG_ORIG(MSG_STR_SLASH)); 2226 (void) strcat(path, file); 2227 DBG_CALL(Dbg_libs_req(ofl->ofl_lml, sdf->sdf_name, 2228 sdf->sdf_rfile, path)); 2229 2230 if ((fd = open(path, O_RDONLY)) == -1) 2231 return (0); 2232 else { 2233 Ifl_desc *ifl; 2234 char *_path; 2235 2236 if ((_path = libld_malloc(strlen(path) + 1)) == 0) 2237 return ((Ifl_desc *)S_ERROR); 2238 (void) strcpy(_path, path); 2239 ifl = ld_process_open(_path, &_path[dlen], &fd, ofl, 0, rej); 2240 if (fd != -1) 2241 (void) close(fd); 2242 return (ifl); 2243 } 2244 } 2245 2246 /* 2247 * Finish any library processing. Walk the list of so's that have been listed 2248 * as "included" by shared objects we have previously processed. Examine them, 2249 * without adding them as explicit dependents of this program, in order to 2250 * complete our symbol definition process. The search path rules are: 2251 * 2252 * o use any user supplied paths, i.e. LD_LIBRARY_PATH and -L, then 2253 * 2254 * o use any RPATH defined within the parent shared object, then 2255 * 2256 * o use the default directories, i.e. LIBPATH or -YP. 2257 */ 2258 uintptr_t 2259 ld_finish_libs(Ofl_desc *ofl) 2260 { 2261 Listnode *lnp1; 2262 Sdf_desc *sdf; 2263 Rej_desc rej = { 0 }; 2264 2265 /* 2266 * Make sure we are back in dynamic mode. 2267 */ 2268 ofl->ofl_flags |= FLG_OF_DYNLIBS; 2269 2270 for (LIST_TRAVERSE(&ofl->ofl_soneed, lnp1, sdf)) { 2271 Listnode *lnp2; 2272 char *path, *slash = NULL; 2273 int fd; 2274 Ifl_desc *ifl; 2275 char *file = (char *)sdf->sdf_name; 2276 2277 /* 2278 * See if this file has already been processed. At the time 2279 * this implicit dependency was determined there may still have 2280 * been more explicit dependencies to process. Note, if we ever 2281 * do parse the command line three times we would be able to 2282 * do all this checking when processing the dynamic section. 2283 */ 2284 if (sdf->sdf_file) 2285 continue; 2286 2287 for (LIST_TRAVERSE(&ofl->ofl_sos, lnp2, ifl)) { 2288 if (!(ifl->ifl_flags & FLG_IF_NEEDSTR) && 2289 (strcmp(file, ifl->ifl_soname) == 0)) { 2290 sdf->sdf_file = ifl; 2291 break; 2292 } 2293 } 2294 if (sdf->sdf_file) 2295 continue; 2296 2297 /* 2298 * If the current path name element embeds a "/", then it's to 2299 * be taken "as is", with no searching involved. Process all 2300 * "/" occurrences, so that we can deduce the base file name. 2301 */ 2302 for (path = file; *path; path++) { 2303 if (*path == '/') 2304 slash = path; 2305 } 2306 if (slash) { 2307 DBG_CALL(Dbg_libs_req(ofl->ofl_lml, sdf->sdf_name, 2308 sdf->sdf_rfile, file)); 2309 if ((fd = open(file, O_RDONLY)) == -1) { 2310 eprintf(ofl->ofl_lml, ERR_WARNING, 2311 MSG_INTL(MSG_FIL_NOTFOUND), file, 2312 sdf->sdf_rfile); 2313 } else { 2314 Rej_desc _rej = { 0 }; 2315 2316 ifl = ld_process_open(file, ++slash, &fd, ofl, 2317 0, &_rej); 2318 if (fd != -1) 2319 (void) close(fd); 2320 2321 if (ifl == (Ifl_desc *)S_ERROR) { 2322 return (S_ERROR); 2323 } 2324 if (_rej.rej_type) { 2325 Conv_reject_desc_buf_t rej_buf; 2326 2327 eprintf(ofl->ofl_lml, ERR_WARNING, 2328 MSG_INTL(reject[_rej.rej_type]), 2329 _rej.rej_name ? rej.rej_name : 2330 MSG_INTL(MSG_STR_UNKNOWN), 2331 conv_reject_desc(&_rej, &rej_buf, 2332 ld_targ.t_m.m_mach)); 2333 } else 2334 sdf->sdf_file = ifl; 2335 } 2336 continue; 2337 } 2338 2339 /* 2340 * Now search for this file in any user defined directories. 2341 */ 2342 for (LIST_TRAVERSE(&ofl->ofl_ulibdirs, lnp2, path)) { 2343 Rej_desc _rej = { 0 }; 2344 2345 ifl = process_req_lib(sdf, path, file, ofl, &_rej); 2346 if (ifl == (Ifl_desc *)S_ERROR) { 2347 return (S_ERROR); 2348 } 2349 if (_rej.rej_type) { 2350 if (rej.rej_type == 0) { 2351 rej = _rej; 2352 rej.rej_name = strdup(_rej.rej_name); 2353 } 2354 } 2355 if (ifl) { 2356 sdf->sdf_file = ifl; 2357 break; 2358 } 2359 } 2360 if (sdf->sdf_file) 2361 continue; 2362 2363 /* 2364 * Next use the local rules defined within the parent shared 2365 * object. 2366 */ 2367 if (sdf->sdf_rpath != NULL) { 2368 char *rpath, *next; 2369 2370 rpath = libld_malloc(strlen(sdf->sdf_rpath) + 1); 2371 if (rpath == 0) 2372 return (S_ERROR); 2373 (void) strcpy(rpath, sdf->sdf_rpath); 2374 DBG_CALL(Dbg_libs_path(ofl->ofl_lml, rpath, 2375 LA_SER_RUNPATH, sdf->sdf_rfile)); 2376 if ((path = strtok_r(rpath, 2377 MSG_ORIG(MSG_STR_COLON), &next)) != NULL) { 2378 do { 2379 Rej_desc _rej = { 0 }; 2380 2381 path = expand(sdf->sdf_rfile, path, 2382 &next); 2383 2384 ifl = process_req_lib(sdf, path, 2385 file, ofl, &_rej); 2386 if (ifl == (Ifl_desc *)S_ERROR) { 2387 return (S_ERROR); 2388 } 2389 if ((_rej.rej_type) && 2390 (rej.rej_type == 0)) { 2391 rej = _rej; 2392 rej.rej_name = 2393 strdup(_rej.rej_name); 2394 } 2395 if (ifl) { 2396 sdf->sdf_file = ifl; 2397 break; 2398 } 2399 } while ((path = strtok_r(NULL, 2400 MSG_ORIG(MSG_STR_COLON), &next)) != NULL); 2401 } 2402 } 2403 if (sdf->sdf_file) 2404 continue; 2405 2406 /* 2407 * Finally try the default library search directories. 2408 */ 2409 for (LIST_TRAVERSE(&ofl->ofl_dlibdirs, lnp2, path)) { 2410 Rej_desc _rej = { 0 }; 2411 2412 ifl = process_req_lib(sdf, path, file, ofl, &rej); 2413 if (ifl == (Ifl_desc *)S_ERROR) { 2414 return (S_ERROR); 2415 } 2416 if (_rej.rej_type) { 2417 if (rej.rej_type == 0) { 2418 rej = _rej; 2419 rej.rej_name = strdup(_rej.rej_name); 2420 } 2421 } 2422 if (ifl) { 2423 sdf->sdf_file = ifl; 2424 break; 2425 } 2426 } 2427 if (sdf->sdf_file) 2428 continue; 2429 2430 /* 2431 * If we've got this far we haven't found the shared object. 2432 * If an object was found, but was rejected for some reason, 2433 * print a diagnostic to that effect, otherwise generate a 2434 * generic "not found" diagnostic. 2435 */ 2436 if (rej.rej_type) { 2437 Conv_reject_desc_buf_t rej_buf; 2438 2439 eprintf(ofl->ofl_lml, ERR_WARNING, 2440 MSG_INTL(reject[rej.rej_type]), 2441 rej.rej_name ? rej.rej_name : 2442 MSG_INTL(MSG_STR_UNKNOWN), 2443 conv_reject_desc(&rej, &rej_buf, 2444 ld_targ.t_m.m_mach)); 2445 } else { 2446 eprintf(ofl->ofl_lml, ERR_WARNING, 2447 MSG_INTL(MSG_FIL_NOTFOUND), file, sdf->sdf_rfile); 2448 } 2449 } 2450 2451 /* 2452 * Finally, now that all objects have been input, make sure any version 2453 * requirements have been met. 2454 */ 2455 return (ld_vers_verify(ofl)); 2456 } 2457