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 2009 Sun Microsystems, Inc. All rights reserved. 27 * Use is subject to license terms. 28 */ 29 30 /* 31 * Map file parsing and input section to output segment mapping. 32 */ 33 #include <stdio.h> 34 #include <string.h> 35 #include <debug.h> 36 #include "msg.h" 37 #include "_libld.h" 38 39 /* 40 * Each time a section is placed, the function set_addralign() 41 * is called. This function performs: 42 * 43 * . if the section is from an external file, check if this is empty or not. 44 * If not, we know the segment this section will belong needs a program 45 * header. (Of course, the program is needed only if this section falls 46 * into a loadable segment.) 47 * . compute the Least Common Multiplier for setting the segment alignment. 48 */ 49 static void 50 set_addralign(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp) 51 { 52 Shdr *shdr = isp->is_shdr; 53 54 /* A discarded section has no influence on the output */ 55 if (isp->is_flags & FLG_IS_DISCARD) 56 return; 57 58 /* 59 * If this section has data or will be assigned data 60 * later, mark this segment not-empty. 61 */ 62 if ((shdr->sh_size != 0) || 63 ((isp->is_flags & FLG_IS_EXTERNAL) == 0)) 64 osp->os_sgdesc->sg_flags |= FLG_SG_PHREQ; 65 66 if ((ofl->ofl_dtflags_1 & DF_1_NOHDR) && 67 (osp->os_sgdesc->sg_phdr).p_type != PT_LOAD) 68 return; 69 70 osp->os_sgdesc->sg_addralign = 71 ld_lcm(osp->os_sgdesc->sg_addralign, shdr->sh_addralign); 72 } 73 74 /* 75 * Return the first input descriptor for a given output descriptor, 76 * or NULL if there are none. 77 */ 78 79 Is_desc * 80 ld_os_first_isdesc(Os_desc *osp) 81 { 82 int i; 83 84 for (i = 0; i < OS_ISD_NUM; i++) { 85 APlist *ap_isdesc = osp->os_isdescs[i]; 86 87 if (aplist_nitems(ap_isdesc) > 0) 88 return ((Is_desc *)ap_isdesc->apl_data[0]); 89 } 90 91 return (NULL); 92 } 93 94 /* 95 * Attach an input section to an output section 96 * 97 * entry: 98 * ofl - File descriptor 99 * osp - Output section descriptor 100 * isp - Input section descriptor 101 * mapfile_sort - True (1) if segment supports mapfile specified ordering 102 * of otherwise unordered input sections, and False (0) otherwise. 103 * 104 * exit: 105 * - The input section has been attached to the output section 106 * - If the input section is a candidate for string table merging, 107 * then it is appended to the output section's list of merge 108 * candidates (os_mstridescs). 109 * 110 * On success, returns True (1). On failure, False (0). 111 */ 112 static int 113 os_attach_isp(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp, int mapfile_sort) 114 { 115 Aliste init_arritems; 116 int os_isdescs_idx, do_append = 1; 117 118 if ((isp->is_flags & FLG_IS_ORDERED) == 0) { 119 init_arritems = AL_CNT_OS_ISDESCS; 120 os_isdescs_idx = OS_ISD_DEFAULT; 121 122 /* 123 * If section ordering was specified for an unordered section 124 * via the mapfile, then search in the OS_ISD_DEFAULT list 125 * and insert it in the specified position. Ordered sections 126 * are placed in ascending order before unordered sections 127 * (sections with an is_ordndx value of zero). 128 * 129 * If no mapfile ordering was specified, we append it in 130 * the usual way below. 131 */ 132 if (mapfile_sort && (isp->is_ordndx > 0)) { 133 APlist *ap_isdesc = osp->os_isdescs[OS_ISD_DEFAULT]; 134 Aliste idx2; 135 Is_desc *isp2; 136 137 for (APLIST_TRAVERSE(ap_isdesc, idx2, isp2)) { 138 if (isp2->is_ordndx && 139 (isp2->is_ordndx <= isp->is_ordndx)) 140 continue; 141 142 if (aplist_insert( 143 &osp->os_isdescs[OS_ISD_DEFAULT], 144 isp, init_arritems, idx2) == NULL) 145 return (0); 146 do_append = 0; 147 break; 148 } 149 } 150 } else { /* Ordered section (via shdr flags) */ 151 Word shndx; 152 153 /* SHF_ORDERED uses sh_info, SHF_LINK_ORDERED uses sh_link */ 154 shndx = (isp->is_shdr->sh_flags & SHF_ORDERED) ? 155 isp->is_shdr->sh_info : isp->is_shdr->sh_link; 156 157 if (shndx == SHN_BEFORE) { 158 init_arritems = AL_CNT_OS_ISDESCS_BA; 159 os_isdescs_idx = OS_ISD_BEFORE; 160 } else if (shndx == SHN_AFTER) { 161 init_arritems = AL_CNT_OS_ISDESCS_BA; 162 os_isdescs_idx = OS_ISD_AFTER; 163 } else { 164 init_arritems = AL_CNT_OS_ISDESCS; 165 os_isdescs_idx = OS_ISD_ORDERED; 166 } 167 } 168 169 /* 170 * If we didn't insert a section into the default list using 171 * mapfile specified ordering above, then append the input 172 * section to the appropriate list. 173 */ 174 if (do_append && aplist_append(&(osp->os_isdescs[os_isdescs_idx]), 175 isp, init_arritems) == NULL) 176 return (0); 177 isp->is_osdesc = osp; 178 179 /* 180 * A section can be merged if the following are true: 181 * - The SHF_MERGE|SHF_STRINGS flags must be set 182 * - String table compression must not be disabled (-znocompstrtab) 183 * - Mapfile ordering must not have been used. 184 * - The section must not be ordered via section header flags. 185 * - It must not be the generated section being built to 186 * replace the sections on this list. 187 */ 188 if (((isp->is_shdr->sh_flags & (SHF_MERGE | SHF_STRINGS)) != 189 (SHF_MERGE | SHF_STRINGS)) || 190 ((ofl->ofl_flags1 & FLG_OF1_NCSTTAB) != 0) || 191 !do_append || 192 ((isp->is_flags & (FLG_IS_ORDERED | FLG_IS_GNSTRMRG)) != 0)) 193 return (1); 194 195 /* 196 * Skip sections with (sh_entsize > 1) or (sh_addralign > 1). 197 * 198 * sh_entsize: 199 * We are currently only able to merge string tables containing 200 * strings with 1-byte (char) characters. Support for wide 201 * characters will require our string table compression code 202 * to be extended to handle larger character sizes. 203 * 204 * sh_addralign: 205 * Alignments greater than 1 would require our string table 206 * compression code to insert null bytes to move each 207 * string to the required alignment. 208 */ 209 if ((isp->is_shdr->sh_entsize > 1) || 210 (isp->is_shdr->sh_addralign > 1)) { 211 DBG_CALL(Dbg_sec_unsup_strmerge(ofl->ofl_lml, isp)); 212 return (1); 213 } 214 215 if (aplist_append(&osp->os_mstrisdescs, isp, 216 AL_CNT_OS_MSTRISDESCS) == NULL) 217 return (0); 218 219 /* 220 * The SHF_MERGE|SHF_STRINGS flags tell us that the program that 221 * created the section intended it to be mergeable. The 222 * FLG_IS_INSTRMRG flag says that we have done validity testing 223 * and decided that it is safe to act on that hint. 224 */ 225 isp->is_flags |= FLG_IS_INSTRMRG; 226 227 return (1); 228 } 229 230 /* 231 * Determine whether this input COMDAT section already exists for the associated 232 * output section. If so, then discard this input section. Otherwise, this 233 * must be the first COMDAT section, thus it is kept for future comparisons. 234 */ 235 static uintptr_t 236 add_comdat(Ofl_desc *ofl, Os_desc *osp, Is_desc *isp) 237 { 238 Isd_node isd, *isdp; 239 avl_tree_t *avlt; 240 avl_index_t where; 241 242 /* 243 * Create a COMDAT avl tree for this output section if required. 244 */ 245 if ((avlt = osp->os_comdats) == NULL) { 246 if ((avlt = libld_calloc(sizeof (avl_tree_t), 1)) == NULL) 247 return (S_ERROR); 248 avl_create(avlt, isdavl_compare, sizeof (Isd_node), 249 SGSOFFSETOF(Isd_node, isd_avl)); 250 osp->os_comdats = avlt; 251 } 252 isd.isd_hash = sgs_str_hash(isp->is_name); 253 isd.isd_isp = isp; 254 255 if ((isdp = avl_find(avlt, &isd, &where)) != NULL) { 256 isp->is_osdesc = osp; 257 258 /* 259 * If this section hasn't already been identified as discarded, 260 * generate a suitable diagnostic. 261 */ 262 if ((isp->is_flags & FLG_IS_DISCARD) == 0) { 263 isp->is_flags |= FLG_IS_DISCARD; 264 isp->is_comdatkeep = isdp->isd_isp; 265 DBG_CALL(Dbg_sec_discarded(ofl->ofl_lml, isp, 266 isdp->isd_isp)); 267 } 268 269 /* 270 * A discarded section does not require assignment to an output 271 * section. However, if relaxed relocations have been enabled 272 * (either from -z relaxreloc, or asserted with .gnu.linkonce 273 * processing), then this section must still be assigned to an 274 * output section so that the sloppy relocation logic will have 275 * the information necessary to do its work. 276 */ 277 return (0); 278 } 279 280 /* 281 * This is a new COMDAT section - so keep it. 282 */ 283 if ((isdp = libld_calloc(sizeof (Isd_node), 1)) == NULL) 284 return (S_ERROR); 285 286 isdp->isd_hash = isd.isd_hash; 287 isdp->isd_isp = isp; 288 289 avl_insert(avlt, isdp, where); 290 return (1); 291 } 292 293 /* 294 * Determine whether a GNU group COMDAT section name follows the convention 295 * 296 * section-name.symbol-name 297 * 298 * Each section within the input file is compared to see if the full section 299 * name matches the beginning of the COMDAT section, with a following '.'. 300 * A pointer to the symbol name, starting with the '.' is returned so that the 301 * caller can strip off the required section name. 302 */ 303 static char * 304 gnu_comdat_sym(Ifl_desc *ifl, Is_desc *gisp) 305 { 306 size_t ndx; 307 308 for (ndx = 1; ndx < ifl->ifl_shnum; ndx++) { 309 Is_desc *isp; 310 size_t ssize; 311 312 if (((isp = ifl->ifl_isdesc[ndx]) == NULL) || 313 (isp == gisp) || (isp->is_name == NULL)) 314 continue; 315 316 /* 317 * It's questionable whether this size should be cached in the 318 * Is_desc. However, this seems an infrequent operation and 319 * adding Is_desc members can escalate memory usage for large 320 * link-edits. For now, size the section name dynamically. 321 */ 322 ssize = strlen(isp->is_name); 323 if ((strncmp(isp->is_name, gisp->is_name, ssize) != 0) && 324 (gisp->is_name[ssize] == '.')) 325 return ((char *)&gisp->is_name[ssize]); 326 } 327 return (NULL); 328 } 329 330 /* 331 * GNU .gnu.linkonce sections follow a naming convention that indicates the 332 * required association with an output section. Determine whether this input 333 * section follows the convention, and if so return the appropriate output 334 * section name. 335 * 336 * .gnu.linkonce.b.* -> .bss 337 * .gnu.linkonce.d.* -> .data 338 * .gnu.linkonce.l.* -> .ldata 339 * .gnu.linkonce.lb.* -> .lbss 340 * .gnu.linkonce.lr.* -> .lrodata 341 * .gnu.linkonce.r.* -> .rodata 342 * .gnu.linkonce.s.* -> .sdata 343 * .gnu.linkonce.s2.* -> .sdata2 344 * .gnu.linkonce.sb.* -> .sbss 345 * .gnu.linkonce.sb2.* -> .sbss2 346 * .gnu.linkonce.t.* -> .text 347 * .gnu.linkonce.tb.* -> .tbss 348 * .gnu.linkonce.td.* -> .tdata 349 * .gnu.linkonce.wi.* -> .debug_info 350 */ 351 #define NSTR_CH1(ch) (*(nstr + 1) == (ch)) 352 #define NSTR_CH2(ch) (*(nstr + 2) == (ch)) 353 #define NSTR_CH3(ch) (*(nstr + 3) == (ch)) 354 355 static const char * 356 gnu_linkonce_sec(const char *ostr) 357 { 358 const char *nstr = &ostr[MSG_SCN_GNU_LINKONCE_SIZE]; 359 360 switch (*nstr) { 361 case 'b': 362 if (NSTR_CH1('.')) 363 return (MSG_ORIG(MSG_SCN_BSS)); 364 break; 365 case 'd': 366 if (NSTR_CH1('.')) 367 return (MSG_ORIG(MSG_SCN_DATA)); 368 break; 369 case 'l': 370 if (NSTR_CH1('.')) 371 return (MSG_ORIG(MSG_SCN_LDATA)); 372 else if (NSTR_CH1('b') && NSTR_CH2('.')) 373 return (MSG_ORIG(MSG_SCN_LBSS)); 374 else if (NSTR_CH1('r') && NSTR_CH2('.')) 375 return (MSG_ORIG(MSG_SCN_LRODATA)); 376 break; 377 case 'r': 378 if (NSTR_CH1('.')) 379 return (MSG_ORIG(MSG_SCN_RODATA)); 380 break; 381 case 's': 382 if (NSTR_CH1('.')) 383 return (MSG_ORIG(MSG_SCN_SDATA)); 384 else if (NSTR_CH1('2') && NSTR_CH2('.')) 385 return (MSG_ORIG(MSG_SCN_SDATA2)); 386 else if (NSTR_CH1('b') && NSTR_CH2('.')) 387 return (MSG_ORIG(MSG_SCN_SBSS)); 388 else if (NSTR_CH1('b') && NSTR_CH2('2') && NSTR_CH3('.')) 389 return (MSG_ORIG(MSG_SCN_SBSS2)); 390 break; 391 case 't': 392 if (NSTR_CH1('.')) 393 return (MSG_ORIG(MSG_SCN_TEXT)); 394 else if (NSTR_CH1('b') && NSTR_CH2('.')) 395 return (MSG_ORIG(MSG_SCN_TBSS)); 396 else if (NSTR_CH1('d') && NSTR_CH2('.')) 397 return (MSG_ORIG(MSG_SCN_TDATA)); 398 break; 399 case 'w': 400 if (NSTR_CH1('i') && NSTR_CH2('.')) 401 return (MSG_ORIG(MSG_SCN_DEBUG_INFO)); 402 break; 403 default: 404 break; 405 } 406 407 /* 408 * No special name match found. 409 */ 410 return (ostr); 411 } 412 #undef NSTR_CH1 413 #undef NSTR_CH2 414 #undef NSTR_CH3 415 416 /* 417 * Place a section into the appropriate segment and output section. 418 * 419 * entry: 420 * ofl - File descriptor 421 * isp - Input section descriptor of section to be placed. 422 * ident - Section identifier, used to order sections relative to 423 * others within the output segment. 424 * alt_os_name - If non-NULL, the name of the output section to place 425 * isp into. If NULL, input sections go to an output section 426 * with the same name as the input section. 427 */ 428 Os_desc * 429 ld_place_section(Ofl_desc *ofl, Is_desc *isp, int ident, 430 const char *alt_os_name) 431 { 432 Ent_desc *enp; 433 Sg_desc *sgp; 434 Os_desc *osp; 435 Aliste idx1, iidx; 436 int os_ndx; 437 Shdr *shdr = isp->is_shdr; 438 Xword shflagmask, shflags = shdr->sh_flags; 439 Ifl_desc *ifl = isp->is_file; 440 char *oname, *sname; 441 uint_t onamehash; 442 443 /* 444 * Define any sections that must be thought of as referenced. These 445 * sections may not be referenced externaly in a manner ld(1) can 446 * discover, but they must be retained (ie. not removed by -zignore). 447 */ 448 static const Msg RefSecs[] = { 449 MSG_SCN_INIT, /* MSG_ORIG(MSG_SCN_INIT) */ 450 MSG_SCN_FINI, /* MSG_ORIG(MSG_SCN_FINI) */ 451 MSG_SCN_EX_RANGES, /* MSG_ORIG(MSG_SCN_EX_RANGES) */ 452 MSG_SCN_EX_SHARED, /* MSG_ORIG(MSG_SCN_EX_SHARED) */ 453 MSG_SCN_CTORS, /* MSG_ORIG(MSG_SCN_CTORS) */ 454 MSG_SCN_DTORS, /* MSG_ORIG(MSG_SCN_DTORS) */ 455 MSG_SCN_EHFRAME, /* MSG_ORIG(MSG_SCN_EHFRAME) */ 456 MSG_SCN_EHFRAME_HDR, /* MSG_ORIG(MSG_SCN_EHFRAME_HDR) */ 457 MSG_SCN_JCR, /* MSG_ORIG(MSG_SCN_JCR) */ 458 0 459 }; 460 461 DBG_CALL(Dbg_sec_in(ofl->ofl_lml, isp)); 462 463 /* 464 * If this section identfies group members, or this section indicates 465 * that it is a member of a group, determine whether the section is 466 * still required. 467 */ 468 if ((shflags & SHF_GROUP) || (shdr->sh_type == SHT_GROUP)) { 469 Group_desc *gdesc; 470 471 if ((gdesc = ld_get_group(ofl, isp)) != NULL) { 472 DBG_CALL(Dbg_sec_group(ofl->ofl_lml, isp, gdesc)); 473 474 /* 475 * If this group has been replaced by another group, 476 * then this section needs to be discarded. 477 */ 478 if (gdesc->gd_oisc) { 479 isp->is_flags |= FLG_IS_DISCARD; 480 481 /* 482 * Since we're discarding the section, we 483 * can skip assigning it to an output section. 484 * The exception is that if the user 485 * specifies -z relaxreloc, then 486 * we need to assign the output section so 487 * that the sloppy relocation logic will have 488 * the information necessary to do its work. 489 */ 490 if (!(ofl->ofl_flags1 & FLG_OF1_RLXREL)) 491 return (NULL); 492 } 493 } 494 495 /* 496 * SHT_GROUP sections can only be included into relocatable 497 * objects. 498 */ 499 if (shdr->sh_type == SHT_GROUP) { 500 if ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) { 501 isp->is_flags |= FLG_IS_DISCARD; 502 return (NULL); 503 } 504 } 505 } 506 507 /* 508 * Always assign SHF_TLS sections to the DATA segment (and then the 509 * PT_TLS embedded inside of there). 510 */ 511 if (shflags & SHF_TLS) 512 shflags |= SHF_WRITE; 513 514 /* 515 * Traverse the entrance criteria list searching for a segment that 516 * matches the input section we have. If an entrance criterion is set 517 * then there must be an exact match. If we complete the loop without 518 * finding a segment, then sgp will be NULL. 519 */ 520 sgp = NULL; 521 for (ALIST_TRAVERSE(ofl->ofl_ents, idx1, enp)) { 522 if (enp->ec_segment && 523 (enp->ec_segment->sg_flags & FLG_SG_DISABLED)) 524 continue; 525 if (enp->ec_type && (enp->ec_type != shdr->sh_type)) 526 continue; 527 if (enp->ec_attrmask && 528 /* LINTED */ 529 (enp->ec_attrmask & enp->ec_attrbits) != 530 (enp->ec_attrmask & shflags)) 531 continue; 532 if (((enp->ec_flags & FLG_EC_BUILTIN) == 0) && 533 enp->ec_name && (strcmp(enp->ec_name, isp->is_name) != 0)) 534 continue; 535 if (enp->ec_files) { 536 Aliste idx2; 537 char *file; 538 int found = 0; 539 540 if (isp->is_file == NULL) 541 continue; 542 543 for (APLIST_TRAVERSE(enp->ec_files, idx2, file)) { 544 const char *name = isp->is_file->ifl_name; 545 546 if (file[0] == '*') { 547 const char *basename; 548 549 basename = strrchr(name, '/'); 550 if (basename == NULL) 551 basename = name; 552 else if (basename[1] != '\0') 553 basename++; 554 555 if (strcmp(&file[1], basename) == 0) { 556 found++; 557 break; 558 } 559 } else { 560 if (strcmp(file, name) == 0) { 561 found++; 562 break; 563 } 564 } 565 } 566 if (!found) 567 continue; 568 } 569 sgp = enp->ec_segment; 570 break; 571 } 572 573 if (sgp == NULL) { 574 enp = alist_item(ofl->ofl_ents, 575 alist_nitems(ofl->ofl_ents) - 1); 576 sgp = enp->ec_segment; 577 } 578 579 /* 580 * If our caller has supplied an alternative name for the output 581 * section, then we defer to their request. Otherwise, the default 582 * is to use the same name as that of the input section being placed. 583 * 584 * The COMDAT, SHT_GROUP and GNU name translations that follow have 585 * the potential to alter this initial name. 586 */ 587 oname = (char *)((alt_os_name == NULL) ? isp->is_name : alt_os_name); 588 589 /* 590 * Solaris section names may follow the convention: 591 * 592 * section-name%symbol-name 593 * 594 * This convention has been used to order the layout of sections within 595 * segments for objects built with the compilers -xF option. However, 596 * the final object should not contain individual section headers for 597 * all such input sections, instead the symbol name is stripped from the 598 * name to establish the final output section name. 599 * 600 * This convention has also been followed for COMDAT and sections 601 * identified though SHT_GROUP data. 602 * 603 * Strip out the % from the section name in all cases except: 604 * 605 * i. when '-r' is used without '-M', and 606 * ii. when '-r' is used with '-M' but without the ?O flag. 607 */ 608 if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) || 609 (sgp->sg_flags & FLG_SG_ORDER)) { 610 if ((sname = strchr(isp->is_name, '%')) != NULL) { 611 size_t size = sname - isp->is_name; 612 613 if ((oname = libld_malloc(size + 1)) == NULL) 614 return ((Os_desc *)S_ERROR); 615 (void) strncpy(oname, isp->is_name, size); 616 oname[size] = '\0'; 617 DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname)); 618 } 619 isp->is_ordndx = enp->ec_ordndx; 620 } 621 622 /* 623 * GNU section names may follow the convention: 624 * 625 * .gnu.linkonce.* 626 * 627 * The .gnu.linkonce is a section naming convention that indicates a 628 * COMDAT requirement. Determine whether this section follows the GNU 629 * pattern, and if so, determine whether this section should be 630 * discarded or retained. The comparison of is_name[1] with 'g' 631 * is an optimization to skip using strncmp() too much. This is safe, 632 * because we know the name is not NULL, and therefore must have 633 * at least one character plus a NULL termination. 634 */ 635 if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) && 636 (isp->is_name == oname) && (isp->is_name[1] == 'g') && 637 (strncmp(MSG_ORIG(MSG_SCN_GNU_LINKONCE), isp->is_name, 638 MSG_SCN_GNU_LINKONCE_SIZE) == 0)) { 639 if ((oname = 640 (char *)gnu_linkonce_sec(isp->is_name)) != isp->is_name) { 641 DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname)); 642 } 643 644 /* 645 * Explicitly identify this section type as COMDAT. Also, 646 * enable lazy relocation processing, as this is typically a 647 * requirement with .gnu.linkonce sections. 648 */ 649 isp->is_flags |= FLG_IS_COMDAT; 650 if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0) 651 ofl->ofl_flags1 |= FLG_OF1_RLXREL; 652 Dbg_sec_gnu_comdat(ofl->ofl_lml, isp, 1, 653 (ofl->ofl_flags1 & FLG_OF1_RLXREL)); 654 } 655 656 /* 657 * GNU section names may also follow the convention: 658 * 659 * section-name.symbol-name 660 * 661 * This convention is used when defining SHT_GROUP sections of type 662 * COMDAT. Thus, any group processing will have discovered any group 663 * sections, and this identification can be triggered by a pattern 664 * match section names. 665 */ 666 if (((ofl->ofl_flags & FLG_OF_RELOBJ) == 0) && 667 (isp->is_name == oname) && (isp->is_flags & FLG_IS_COMDAT) && 668 ((sname = gnu_comdat_sym(ifl, isp)) != NULL)) { 669 size_t size = sname - isp->is_name; 670 671 if ((oname = libld_malloc(size + 1)) == NULL) 672 return ((Os_desc *)S_ERROR); 673 (void) strncpy(oname, isp->is_name, size); 674 oname[size] = '\0'; 675 DBG_CALL(Dbg_sec_redirected(ofl->ofl_lml, isp, oname)); 676 677 /* 678 * Enable lazy relocation processing, as this is typically a 679 * requirement with GNU COMDAT sections. 680 */ 681 if ((ofl->ofl_flags1 & FLG_OF1_NRLXREL) == 0) { 682 ofl->ofl_flags1 |= FLG_OF1_RLXREL; 683 Dbg_sec_gnu_comdat(ofl->ofl_lml, isp, 0, 684 (ofl->ofl_flags1 & FLG_OF1_RLXREL)); 685 } 686 } 687 688 /* 689 * Assign a hash value now that the output section name has been 690 * finalized. 691 */ 692 onamehash = sgs_str_hash(oname); 693 694 if (sgp->sg_flags & FLG_SG_ORDER) 695 enp->ec_flags |= FLG_EC_USED; 696 697 /* 698 * Determine if section ordering is turned on. If so, return the 699 * appropriate ordering index for the section. This information 700 * is derived from the Sg_desc->sg_segorder list that was built 701 * up from the Mapfile. 702 */ 703 os_ndx = 0; 704 if (sgp->sg_secorder) { 705 Sec_order *scop; 706 707 for (APLIST_TRAVERSE(sgp->sg_secorder, idx1, scop)) { 708 if (strcmp(scop->sco_secname, oname) == 0) { 709 scop->sco_flags |= FLG_SGO_USED; 710 os_ndx = scop->sco_index; 711 break; 712 } 713 } 714 } 715 716 /* 717 * Mask of section header flags to ignore when matching sections. We 718 * are more strict with relocatable objects, ignoring only the order 719 * flags, and keeping sections apart if they differ otherwise. This 720 * follows the policy that sections in a relative object should only 721 * be merged if their flags are the same, and avoids destroying 722 * information prematurely. For final products however, we ignore all 723 * flags that do not prevent a merge. 724 */ 725 shflagmask = 726 (ofl->ofl_flags & FLG_OF_RELOBJ) ? ALL_SHF_ORDER : ALL_SHF_IGNORE; 727 728 /* 729 * Traverse the input section list for the output section we have been 730 * assigned. If we find a matching section simply add this new section. 731 */ 732 iidx = 0; 733 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx1, osp)) { 734 Shdr *_shdr = osp->os_shdr; 735 736 if ((ident == osp->os_identndx) && 737 (ident != ld_targ.t_id.id_rel) && 738 (onamehash == osp->os_namehash) && 739 (shdr->sh_type != SHT_GROUP) && 740 (shdr->sh_type != SHT_SUNW_dof) && 741 ((shdr->sh_type == _shdr->sh_type) || 742 ((shdr->sh_type == SHT_SUNW_COMDAT) && 743 (_shdr->sh_type == SHT_PROGBITS))) && 744 ((shflags & ~shflagmask) == 745 (_shdr->sh_flags & ~shflagmask)) && 746 (strcmp(oname, osp->os_name) == 0)) { 747 uintptr_t err; 748 749 /* 750 * Process any COMDAT section, keeping the first and 751 * discarding all others. 752 */ 753 if ((isp->is_flags & FLG_IS_COMDAT) && 754 ((err = add_comdat(ofl, osp, isp)) != 1)) 755 return ((Os_desc *)err); 756 757 /* 758 * Set alignment 759 */ 760 set_addralign(ofl, osp, isp); 761 762 /* 763 * If this section is a non-empty TLS section indicate 764 * that a PT_TLS program header is required. 765 */ 766 if ((shflags & SHF_TLS) && shdr->sh_size && 767 ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) 768 ofl->ofl_flags |= FLG_OF_TLSPHDR; 769 770 /* 771 * Insert the input section descriptor on the proper 772 * output section descriptor list. 773 * 774 * If this segment requires input section ordering, 775 * honor any mapfile specified ordering for otherwise 776 * unordered sections by setting the mapfile_sort 777 * argument of os_attach_isp() to True. 778 */ 779 780 if (os_attach_isp(ofl, osp, isp, 781 (sgp->sg_flags & FLG_SG_ORDER) != 0) == 0) 782 return ((Os_desc *)S_ERROR); 783 784 /* 785 * If this input section and file is associated to an 786 * artificially referenced output section, make sure 787 * they are marked as referenced also. This ensures 788 * that this input section and file isn't eliminated 789 * when -zignore is in effect. 790 * 791 * See -zignore comments when creating a new output 792 * section below. 793 */ 794 if (((ifl && 795 (ifl->ifl_flags & FLG_IF_IGNORE)) || DBG_ENABLED) && 796 (osp->os_flags & FLG_OS_SECTREF)) { 797 isp->is_flags |= FLG_IS_SECTREF; 798 if (ifl) 799 ifl->ifl_flags |= FLG_IF_FILEREF; 800 } 801 802 DBG_CALL(Dbg_sec_added(ofl->ofl_lml, osp, sgp)); 803 return (osp); 804 } 805 806 /* 807 * Do we need to worry about section ordering? 808 */ 809 if (os_ndx) { 810 if (osp->os_ordndx) { 811 if (os_ndx < osp->os_ordndx) 812 /* insert section here. */ 813 break; 814 else { 815 iidx = idx1 + 1; 816 continue; 817 } 818 } else { 819 /* insert section here. */ 820 break; 821 } 822 } else if (osp->os_ordndx) { 823 iidx = idx1 + 1; 824 continue; 825 } 826 827 /* 828 * If the new sections identifier is less than that of the 829 * present input section we need to insert the new section 830 * at this point. 831 */ 832 if (ident < osp->os_identndx) 833 break; 834 835 iidx = idx1 + 1; 836 } 837 838 /* 839 * We are adding a new output section. Update the section header 840 * count and associated string size. 841 */ 842 ofl->ofl_shdrcnt++; 843 if (st_insert(ofl->ofl_shdrsttab, oname) == -1) 844 return ((Os_desc *)S_ERROR); 845 846 /* 847 * Create a new output section descriptor. 848 */ 849 if ((osp = libld_calloc(sizeof (Os_desc), 1)) == NULL) 850 return ((Os_desc *)S_ERROR); 851 if ((osp->os_shdr = libld_calloc(sizeof (Shdr), 1)) == NULL) 852 return ((Os_desc *)S_ERROR); 853 854 /* 855 * Convert COMDAT section to PROGBITS as this the first section of the 856 * output section. Save any COMDAT section for later processing, as 857 * additional COMDAT sections that match this section need discarding. 858 */ 859 if (shdr->sh_type == SHT_SUNW_COMDAT) { 860 Shdr *tshdr; 861 862 if ((tshdr = libld_malloc(sizeof (Shdr))) == NULL) 863 return ((Os_desc *)S_ERROR); 864 *tshdr = *shdr; 865 isp->is_shdr = shdr = tshdr; 866 shdr->sh_type = SHT_PROGBITS; 867 } 868 if ((isp->is_flags & FLG_IS_COMDAT) && 869 (add_comdat(ofl, osp, isp) == S_ERROR)) 870 return ((Os_desc *)S_ERROR); 871 872 osp->os_shdr->sh_type = shdr->sh_type; 873 osp->os_shdr->sh_flags = shdr->sh_flags; 874 osp->os_shdr->sh_entsize = shdr->sh_entsize; 875 osp->os_name = oname; 876 osp->os_namehash = onamehash; 877 osp->os_ordndx = os_ndx; 878 osp->os_sgdesc = sgp; 879 880 if (ifl && (shdr->sh_type == SHT_PROGBITS)) { 881 /* 882 * Try to preserve the intended meaning of sh_link/sh_info. 883 * See the translate_link() in update.c. 884 */ 885 osp->os_shdr->sh_link = shdr->sh_link; 886 if (shdr->sh_flags & SHF_INFO_LINK) 887 osp->os_shdr->sh_info = shdr->sh_info; 888 } 889 890 /* 891 * When -zignore is in effect, user supplied sections and files that are 892 * not referenced from other sections, are eliminated from the object 893 * being produced. Some sections, although unreferenced, are special, 894 * and must not be eliminated. Determine if this new output section is 895 * one of those special sections, and if so mark it artificially as 896 * referenced. Any input section and file associated to this output 897 * section is also be marked as referenced, and thus won't be eliminated 898 * from the final output. 899 */ 900 if (ifl && ((ofl->ofl_flags1 & FLG_OF1_IGNPRC) || DBG_ENABLED)) { 901 const Msg *refsec; 902 903 for (refsec = RefSecs; *refsec; refsec++) { 904 if (strcmp(osp->os_name, MSG_ORIG(*refsec)) == 0) { 905 osp->os_flags |= FLG_OS_SECTREF; 906 907 if ((ifl->ifl_flags & FLG_IF_IGNORE) || 908 DBG_ENABLED) { 909 isp->is_flags |= FLG_IS_SECTREF; 910 ifl->ifl_flags |= FLG_IF_FILEREF; 911 } 912 break; 913 } 914 } 915 } 916 917 /* 918 * Sections of type SHT_GROUP are added to the ofl->ofl_osgroups list, 919 * so that they can be updated as a group later. 920 */ 921 if ((shdr->sh_type == SHT_GROUP) && 922 (aplist_append(&ofl->ofl_osgroups, osp, 923 AL_CNT_OFL_OSGROUPS) == NULL)) 924 return ((Os_desc *)S_ERROR); 925 926 /* 927 * If this section is a non-empty TLS section indicate that a PT_TLS 928 * program header is required. 929 */ 930 if ((shflags & SHF_TLS) && shdr->sh_size && 931 ((ofl->ofl_flags & FLG_OF_RELOBJ) == 0)) 932 ofl->ofl_flags |= FLG_OF_TLSPHDR; 933 934 /* 935 * If a non-allocatable section is going to be put into a loadable 936 * segment then turn on the allocate bit for this section and warn the 937 * user that we have done so. This could only happen through the use 938 * of a mapfile. 939 */ 940 if ((sgp->sg_phdr.p_type == PT_LOAD) && 941 ((osp->os_shdr->sh_flags & SHF_ALLOC) == 0)) { 942 eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_SCN_NONALLOC), 943 ofl->ofl_name, osp->os_name); 944 osp->os_shdr->sh_flags |= SHF_ALLOC; 945 } 946 947 /* 948 * Retain this sections identifier for future comparisons when placing 949 * a section (after all sections have been processed this variable will 950 * be used to hold the sections symbol index as we don't need to retain 951 * the identifier any more). 952 */ 953 osp->os_identndx = ident; 954 955 /* 956 * Set alignment. 957 */ 958 set_addralign(ofl, osp, isp); 959 960 if (os_attach_isp(ofl, osp, isp, 0) == 0) 961 return ((Os_desc *)S_ERROR); 962 963 DBG_CALL(Dbg_sec_created(ofl->ofl_lml, osp, sgp)); 964 965 /* 966 * Insert the new section at the offset given by iidx. If no position 967 * for it was identified above, this will be index 0, causing the new 968 * section to be prepended to the beginning of the section list. 969 * Otherwise, it is the index following the section that was identified. 970 */ 971 if (aplist_insert(&sgp->sg_osdescs, osp, AL_CNT_SG_OSDESC, 972 iidx) == NULL) 973 return ((Os_desc *)S_ERROR); 974 return (osp); 975 } 976