17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 55aefb655Srie * Common Development and Distribution License (the "License"). 65aefb655Srie * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 215aefb655Srie 227c478bd9Sstevel@tonic-gate /* 237c478bd9Sstevel@tonic-gate * Copyright (c) 1988 AT&T 247c478bd9Sstevel@tonic-gate * All Rights Reserved 257c478bd9Sstevel@tonic-gate * 267c478bd9Sstevel@tonic-gate * 27*9a411307Srie * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 287c478bd9Sstevel@tonic-gate * Use is subject to license terms. 297c478bd9Sstevel@tonic-gate */ 307c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 317c478bd9Sstevel@tonic-gate 327c478bd9Sstevel@tonic-gate /* 337c478bd9Sstevel@tonic-gate * Symbol table management routines 347c478bd9Sstevel@tonic-gate */ 357c478bd9Sstevel@tonic-gate #include <stdio.h> 367c478bd9Sstevel@tonic-gate #include <string.h> 375aefb655Srie #include <debug.h> 387c478bd9Sstevel@tonic-gate #include "msg.h" 397c478bd9Sstevel@tonic-gate #include "_libld.h" 407c478bd9Sstevel@tonic-gate 417c478bd9Sstevel@tonic-gate /* 427c478bd9Sstevel@tonic-gate * AVL tree comparator function: 437c478bd9Sstevel@tonic-gate * 447c478bd9Sstevel@tonic-gate * The primary key is the 'sa_hashval' with a secondary 457c478bd9Sstevel@tonic-gate * key of the symbol name itself. 467c478bd9Sstevel@tonic-gate */ 477c478bd9Sstevel@tonic-gate int 485aefb655Srie ld_sym_avl_comp(const void *elem1, const void *elem2) 497c478bd9Sstevel@tonic-gate { 507c478bd9Sstevel@tonic-gate int res; 517c478bd9Sstevel@tonic-gate Sym_avlnode *sav1 = (Sym_avlnode *)elem1; 527c478bd9Sstevel@tonic-gate Sym_avlnode *sav2 = (Sym_avlnode *)elem2; 537c478bd9Sstevel@tonic-gate 547c478bd9Sstevel@tonic-gate res = sav1->sav_hash - sav2->sav_hash; 557c478bd9Sstevel@tonic-gate 567c478bd9Sstevel@tonic-gate if (res < 0) 577c478bd9Sstevel@tonic-gate return (-1); 587c478bd9Sstevel@tonic-gate if (res > 0) 597c478bd9Sstevel@tonic-gate return (1); 607c478bd9Sstevel@tonic-gate 617c478bd9Sstevel@tonic-gate /* 627c478bd9Sstevel@tonic-gate * Hash is equal - now compare name 637c478bd9Sstevel@tonic-gate */ 647c478bd9Sstevel@tonic-gate res = strcmp(sav1->sav_name, sav2->sav_name); 657c478bd9Sstevel@tonic-gate if (res == 0) 667c478bd9Sstevel@tonic-gate return (0); 677c478bd9Sstevel@tonic-gate if (res > 0) 687c478bd9Sstevel@tonic-gate return (1); 697c478bd9Sstevel@tonic-gate return (-1); 707c478bd9Sstevel@tonic-gate } 717c478bd9Sstevel@tonic-gate 727c478bd9Sstevel@tonic-gate 737c478bd9Sstevel@tonic-gate /* 747c478bd9Sstevel@tonic-gate * Focal point for verifying symbol names. 757c478bd9Sstevel@tonic-gate */ 765aefb655Srie static const char * 775aefb655Srie string(Ofl_desc *ofl, Ifl_desc *ifl, Sym *sym, const char *strs, size_t strsize, 785aefb655Srie int symndx, Word shndx, const char *symsecname, const char *strsecname, 795aefb655Srie Word *flags) 807c478bd9Sstevel@tonic-gate { 817c478bd9Sstevel@tonic-gate const char *regname; 827c478bd9Sstevel@tonic-gate Word name = sym->st_name; 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate if (name) { 857c478bd9Sstevel@tonic-gate if ((ifl->ifl_flags & FLG_IF_HSTRTAB) == 0) { 865aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 875aefb655Srie MSG_INTL(MSG_FIL_NOSTRTABLE), ifl->ifl_name, 885aefb655Srie symsecname, symndx, EC_XWORD(name)); 897c478bd9Sstevel@tonic-gate return (0); 907c478bd9Sstevel@tonic-gate } 917c478bd9Sstevel@tonic-gate if (name >= (Word)strsize) { 925aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 935aefb655Srie MSG_INTL(MSG_FIL_EXCSTRTABLE), ifl->ifl_name, 945aefb655Srie symsecname, symndx, EC_XWORD(name), 957c478bd9Sstevel@tonic-gate strsecname, EC_XWORD(strsize)); 967c478bd9Sstevel@tonic-gate return (0); 977c478bd9Sstevel@tonic-gate } 987c478bd9Sstevel@tonic-gate } 997c478bd9Sstevel@tonic-gate 1007c478bd9Sstevel@tonic-gate /* 1017c478bd9Sstevel@tonic-gate * Determine if we're dealing with a register and if so validate it. 1027c478bd9Sstevel@tonic-gate * If it's a scratch register, a fabricated name will be returned. 1037c478bd9Sstevel@tonic-gate */ 1045aefb655Srie if ((regname = ld_is_regsym(ofl, ifl, sym, strs, symndx, shndx, 1057c478bd9Sstevel@tonic-gate symsecname, flags)) == (const char *)S_ERROR) { 1067c478bd9Sstevel@tonic-gate return (0); 1077c478bd9Sstevel@tonic-gate } 1087c478bd9Sstevel@tonic-gate if (regname) 1097c478bd9Sstevel@tonic-gate return (regname); 1107c478bd9Sstevel@tonic-gate 1117c478bd9Sstevel@tonic-gate /* 1127c478bd9Sstevel@tonic-gate * If this isn't a register, but we have a global symbol with a null 1137c478bd9Sstevel@tonic-gate * name, we're not going to be able to hash this, search for it, or 1147c478bd9Sstevel@tonic-gate * do anything interesting. However, we've been accepting a symbol of 1157c478bd9Sstevel@tonic-gate * this kind for ages now, so give the user a warning (rather than a 1167c478bd9Sstevel@tonic-gate * fatal error), just in case this instance exists somewhere in the 1177c478bd9Sstevel@tonic-gate * world and hasn't, as yet, been a problem. 1187c478bd9Sstevel@tonic-gate */ 1197c478bd9Sstevel@tonic-gate if ((name == 0) && (ELF_ST_BIND(sym->st_info) != STB_LOCAL)) { 1205aefb655Srie eprintf(ofl->ofl_lml, ERR_WARNING, MSG_INTL(MSG_FIL_NONAMESYM), 1217c478bd9Sstevel@tonic-gate ifl->ifl_name, symsecname, symndx, EC_XWORD(name)); 1227c478bd9Sstevel@tonic-gate } 1237c478bd9Sstevel@tonic-gate return (strs + name); 1247c478bd9Sstevel@tonic-gate } 1257c478bd9Sstevel@tonic-gate 1267c478bd9Sstevel@tonic-gate /* 1277c478bd9Sstevel@tonic-gate * Shared objects can be built that define specific symbols that can not be 1287c478bd9Sstevel@tonic-gate * directly bound to. These objects have a syminfo section (and an associated 1297c478bd9Sstevel@tonic-gate * DF_1_NODIRECT dynamic flags entry). Scan this table looking for symbols 1307c478bd9Sstevel@tonic-gate * that can't be bound to directly, and if this files symbol is presently 1317c478bd9Sstevel@tonic-gate * referenced, mark it so that we don't directly bind to it. 1327c478bd9Sstevel@tonic-gate */ 1337c478bd9Sstevel@tonic-gate uintptr_t 134*9a411307Srie ld_sym_nodirect(Is_desc *isp, Ifl_desc *ifl, Ofl_desc *ofl) 1357c478bd9Sstevel@tonic-gate { 1367c478bd9Sstevel@tonic-gate Shdr *sifshdr, *symshdr; 1377c478bd9Sstevel@tonic-gate Syminfo *sifdata; 1387c478bd9Sstevel@tonic-gate Sym *symdata; 1397c478bd9Sstevel@tonic-gate char *strdata; 1407c478bd9Sstevel@tonic-gate ulong_t cnt, _cnt; 1417c478bd9Sstevel@tonic-gate 1427c478bd9Sstevel@tonic-gate /* 1437c478bd9Sstevel@tonic-gate * Get the syminfo data, and determine the number of entries. 1447c478bd9Sstevel@tonic-gate */ 1457c478bd9Sstevel@tonic-gate sifshdr = isp->is_shdr; 1467c478bd9Sstevel@tonic-gate sifdata = (Syminfo *)isp->is_indata->d_buf; 1477c478bd9Sstevel@tonic-gate cnt = sifshdr->sh_size / sifshdr->sh_entsize; 1487c478bd9Sstevel@tonic-gate 1497c478bd9Sstevel@tonic-gate /* 1507c478bd9Sstevel@tonic-gate * Get the associated symbol table. 1517c478bd9Sstevel@tonic-gate */ 1527c478bd9Sstevel@tonic-gate symshdr = ifl->ifl_isdesc[sifshdr->sh_link]->is_shdr; 1537c478bd9Sstevel@tonic-gate symdata = ifl->ifl_isdesc[sifshdr->sh_link]->is_indata->d_buf; 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate /* 1567c478bd9Sstevel@tonic-gate * Get the string table associated with the symbol table. 1577c478bd9Sstevel@tonic-gate */ 1587c478bd9Sstevel@tonic-gate strdata = ifl->ifl_isdesc[symshdr->sh_link]->is_indata->d_buf; 1597c478bd9Sstevel@tonic-gate 1607c478bd9Sstevel@tonic-gate /* 1617c478bd9Sstevel@tonic-gate * Traverse the syminfo data for symbols that can't be directly 1627c478bd9Sstevel@tonic-gate * bound to. 1637c478bd9Sstevel@tonic-gate */ 1647c478bd9Sstevel@tonic-gate for (_cnt = 1, sifdata++; _cnt < cnt; _cnt++, sifdata++) { 1657c478bd9Sstevel@tonic-gate Sym *sym; 1667c478bd9Sstevel@tonic-gate char *str; 1677c478bd9Sstevel@tonic-gate Sym_desc *sdp; 1687c478bd9Sstevel@tonic-gate 1697c478bd9Sstevel@tonic-gate if (((sifdata->si_flags & SYMINFO_FLG_NOEXTDIRECT) == 0) || 1707c478bd9Sstevel@tonic-gate (sifdata->si_boundto < SYMINFO_BT_LOWRESERVE)) 1717c478bd9Sstevel@tonic-gate continue; 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate sym = (Sym *)(symdata + _cnt); 1747c478bd9Sstevel@tonic-gate str = (char *)(strdata + sym->st_name); 1757c478bd9Sstevel@tonic-gate 1765aefb655Srie if (sdp = ld_sym_find(str, SYM_NOHASH, 0, ofl)) { 1777c478bd9Sstevel@tonic-gate if (ifl != sdp->sd_file) 1787c478bd9Sstevel@tonic-gate continue; 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate sdp->sd_flags1 &= ~FLG_SY1_DIR; 1817c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_NDIR; 1827c478bd9Sstevel@tonic-gate } 1837c478bd9Sstevel@tonic-gate } 1847c478bd9Sstevel@tonic-gate return (0); 1857c478bd9Sstevel@tonic-gate } 1867c478bd9Sstevel@tonic-gate 1877c478bd9Sstevel@tonic-gate /* 1887c478bd9Sstevel@tonic-gate * If, during symbol processing, it is necessary to update a local symbols 1897c478bd9Sstevel@tonic-gate * contents before we have generated the symbol tables in the output image, 1907c478bd9Sstevel@tonic-gate * create a new symbol structure and copy the original symbol contents. While 1917c478bd9Sstevel@tonic-gate * we are processing the input files, their local symbols are part of the 1927c478bd9Sstevel@tonic-gate * read-only mapped image. Commonly, these symbols are copied to the new output 1937c478bd9Sstevel@tonic-gate * file image and then updated to reflect their new address and any change in 1947c478bd9Sstevel@tonic-gate * attributes. However, sometimes during relocation counting, it is necessary 1957c478bd9Sstevel@tonic-gate * to adjust the symbols information. This routine provides for the generation 1967c478bd9Sstevel@tonic-gate * of a new symbol image so that this update can be performed. 1977c478bd9Sstevel@tonic-gate * All global symbols are copied to an internal symbol table to improve locality 1987c478bd9Sstevel@tonic-gate * of reference and hence performance, and thus this copying is not necessary. 1997c478bd9Sstevel@tonic-gate */ 2007c478bd9Sstevel@tonic-gate uintptr_t 2015aefb655Srie ld_sym_copy(Sym_desc *sdp) 2027c478bd9Sstevel@tonic-gate { 2037c478bd9Sstevel@tonic-gate Sym *nsym; 2047c478bd9Sstevel@tonic-gate 2057c478bd9Sstevel@tonic-gate if (sdp->sd_flags & FLG_SY_CLEAN) { 2067c478bd9Sstevel@tonic-gate if ((nsym = libld_malloc(sizeof (Sym))) == 0) 2077c478bd9Sstevel@tonic-gate return (S_ERROR); 2087c478bd9Sstevel@tonic-gate *nsym = *(sdp->sd_sym); 2097c478bd9Sstevel@tonic-gate sdp->sd_sym = nsym; 2107c478bd9Sstevel@tonic-gate sdp->sd_flags &= ~FLG_SY_CLEAN; 2117c478bd9Sstevel@tonic-gate } 2127c478bd9Sstevel@tonic-gate return (1); 2137c478bd9Sstevel@tonic-gate } 2147c478bd9Sstevel@tonic-gate 2157c478bd9Sstevel@tonic-gate /* 2167c478bd9Sstevel@tonic-gate * Finds a given name in the link editors internal symbol table. If no 2177c478bd9Sstevel@tonic-gate * hash value is specified it is calculated. A pointer to the located 2187c478bd9Sstevel@tonic-gate * Sym_desc entry is returned, or NULL if the symbol is not found. 2197c478bd9Sstevel@tonic-gate */ 2207c478bd9Sstevel@tonic-gate Sym_desc * 2215aefb655Srie ld_sym_find(const char *name, Word hash, avl_index_t *where, Ofl_desc *ofl) 2227c478bd9Sstevel@tonic-gate { 2237c478bd9Sstevel@tonic-gate Sym_avlnode qsav; 2247c478bd9Sstevel@tonic-gate Sym_avlnode *sav; 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate if (hash == SYM_NOHASH) 2277c478bd9Sstevel@tonic-gate /* LINTED */ 2287c478bd9Sstevel@tonic-gate hash = (Word)elf_hash((const char *)name); 2297c478bd9Sstevel@tonic-gate qsav.sav_hash = hash; 2307c478bd9Sstevel@tonic-gate qsav.sav_name = name; 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate /* 2337c478bd9Sstevel@tonic-gate * Perform search for symbol in AVL tree. Note that the 'where' field 2347c478bd9Sstevel@tonic-gate * is passed in from the caller. If a 'where' is present, it can be 2357c478bd9Sstevel@tonic-gate * used in subsequent 'sym_enter()' calls if required. 2367c478bd9Sstevel@tonic-gate */ 2377c478bd9Sstevel@tonic-gate sav = avl_find(&ofl->ofl_symavl, &qsav, where); 2387c478bd9Sstevel@tonic-gate 2397c478bd9Sstevel@tonic-gate /* 2407c478bd9Sstevel@tonic-gate * If symbol was not found in the avl tree, return null to show that. 2417c478bd9Sstevel@tonic-gate */ 2427c478bd9Sstevel@tonic-gate if (sav == 0) 2437c478bd9Sstevel@tonic-gate return (0); 2447c478bd9Sstevel@tonic-gate 2457c478bd9Sstevel@tonic-gate /* 2467c478bd9Sstevel@tonic-gate * Return symbol found. 2477c478bd9Sstevel@tonic-gate */ 2487c478bd9Sstevel@tonic-gate return (sav->sav_symdesc); 2497c478bd9Sstevel@tonic-gate } 2507c478bd9Sstevel@tonic-gate 2517c478bd9Sstevel@tonic-gate 2527c478bd9Sstevel@tonic-gate /* 2537c478bd9Sstevel@tonic-gate * Enter a new symbol into the link editors internal symbol table. 2547c478bd9Sstevel@tonic-gate * If the symbol is from an input file, information regarding the input file 2557c478bd9Sstevel@tonic-gate * and input section is also recorded. Otherwise (file == NULL) the symbol 2567c478bd9Sstevel@tonic-gate * has been internally generated (ie. _etext, _edata, etc.). 2577c478bd9Sstevel@tonic-gate */ 2587c478bd9Sstevel@tonic-gate Sym_desc * 2595aefb655Srie ld_sym_enter(const char *name, Sym *osym, Word hash, Ifl_desc *ifl, 2605aefb655Srie Ofl_desc *ofl, Word ndx, Word shndx, Word sdflags, Half sdflags1, 2615aefb655Srie avl_index_t *where) 2627c478bd9Sstevel@tonic-gate { 2637c478bd9Sstevel@tonic-gate Sym_desc *sdp; 2647c478bd9Sstevel@tonic-gate Sym_aux *sap; 2657c478bd9Sstevel@tonic-gate Sym_avlnode *savl; 2667c478bd9Sstevel@tonic-gate char *_name; 2677c478bd9Sstevel@tonic-gate Sym *nsym; 2687c478bd9Sstevel@tonic-gate Half etype; 2697c478bd9Sstevel@tonic-gate avl_index_t _where; 2707c478bd9Sstevel@tonic-gate 2717c478bd9Sstevel@tonic-gate /* 2727c478bd9Sstevel@tonic-gate * Establish the file type. 2737c478bd9Sstevel@tonic-gate */ 2747c478bd9Sstevel@tonic-gate if (ifl) 2757c478bd9Sstevel@tonic-gate etype = ifl->ifl_ehdr->e_type; 2767c478bd9Sstevel@tonic-gate else 2777c478bd9Sstevel@tonic-gate etype = ET_NONE; 2787c478bd9Sstevel@tonic-gate 2797c478bd9Sstevel@tonic-gate ofl->ofl_entercnt++; 2807c478bd9Sstevel@tonic-gate 2817c478bd9Sstevel@tonic-gate /* 2827c478bd9Sstevel@tonic-gate * Allocate a Sym Descriptor, Auxiliary Descriptor, and a Sym AVLNode - 2837c478bd9Sstevel@tonic-gate * contiguously. 2847c478bd9Sstevel@tonic-gate */ 2857c478bd9Sstevel@tonic-gate if ((savl = libld_calloc(sizeof (Sym_avlnode) + sizeof (Sym_desc) + 2867c478bd9Sstevel@tonic-gate sizeof (Sym_aux), 1)) == 0) 2877c478bd9Sstevel@tonic-gate return ((Sym_desc *)S_ERROR); 2887c478bd9Sstevel@tonic-gate sdp = (Sym_desc *)((uintptr_t)savl + sizeof (Sym_avlnode)); 2897c478bd9Sstevel@tonic-gate sap = (Sym_aux *)((uintptr_t)sdp + sizeof (Sym_desc)); 2907c478bd9Sstevel@tonic-gate 2917c478bd9Sstevel@tonic-gate savl->sav_symdesc = sdp; 2927c478bd9Sstevel@tonic-gate sdp->sd_file = ifl; 2937c478bd9Sstevel@tonic-gate sdp->sd_aux = sap; 2947c478bd9Sstevel@tonic-gate savl->sav_hash = sap->sa_hash = hash; 2957c478bd9Sstevel@tonic-gate 2967c478bd9Sstevel@tonic-gate 2977c478bd9Sstevel@tonic-gate /* 2987c478bd9Sstevel@tonic-gate * Copy the symbol table entry from the input file into the internal 2997c478bd9Sstevel@tonic-gate * entry and have the symbol descriptor use it. 3007c478bd9Sstevel@tonic-gate */ 3017c478bd9Sstevel@tonic-gate sdp->sd_sym = nsym = &sap->sa_sym; 3027c478bd9Sstevel@tonic-gate *nsym = *osym; 3037c478bd9Sstevel@tonic-gate sdp->sd_shndx = shndx; 3047c478bd9Sstevel@tonic-gate sdp->sd_flags |= sdflags; 3057c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= sdflags1; 3067c478bd9Sstevel@tonic-gate 3077c478bd9Sstevel@tonic-gate if ((_name = libld_malloc(strlen(name) + 1)) == 0) 3087c478bd9Sstevel@tonic-gate return ((Sym_desc *)S_ERROR); 3097c478bd9Sstevel@tonic-gate savl->sav_name = sdp->sd_name = (const char *)strcpy(_name, name); 3107c478bd9Sstevel@tonic-gate 3117c478bd9Sstevel@tonic-gate /* 3127c478bd9Sstevel@tonic-gate * Enter Symbol in AVL tree. 3137c478bd9Sstevel@tonic-gate */ 3147c478bd9Sstevel@tonic-gate if (where == 0) { 3157c478bd9Sstevel@tonic-gate /* LINTED */ 3167c478bd9Sstevel@tonic-gate Sym_avlnode *_savl; 3177c478bd9Sstevel@tonic-gate /* 3185aefb655Srie * If a previous ld_sym_find() hasn't initialized 'where' do it 3197c478bd9Sstevel@tonic-gate * now. 3207c478bd9Sstevel@tonic-gate */ 3217c478bd9Sstevel@tonic-gate where = &_where; 3227c478bd9Sstevel@tonic-gate _savl = avl_find(&ofl->ofl_symavl, savl, where); 3237c478bd9Sstevel@tonic-gate assert(_savl == 0); 3247c478bd9Sstevel@tonic-gate } 3257c478bd9Sstevel@tonic-gate avl_insert(&ofl->ofl_symavl, savl, *where); 3267c478bd9Sstevel@tonic-gate 3277c478bd9Sstevel@tonic-gate /* 3287c478bd9Sstevel@tonic-gate * Record the section index. This is possible because the 3297c478bd9Sstevel@tonic-gate * `ifl_isdesc' table is filled before we start symbol processing. 3307c478bd9Sstevel@tonic-gate */ 3310bc07c75Srie if ((sdflags & FLG_SY_SPECSEC) || (nsym->st_shndx == SHN_UNDEF)) 3327c478bd9Sstevel@tonic-gate sdp->sd_isc = NULL; 3337c478bd9Sstevel@tonic-gate else { 3347c478bd9Sstevel@tonic-gate sdp->sd_isc = ifl->ifl_isdesc[shndx]; 3357c478bd9Sstevel@tonic-gate 3367c478bd9Sstevel@tonic-gate /* 3377c478bd9Sstevel@tonic-gate * If this symbol is from a relocatable object, make sure that 3387c478bd9Sstevel@tonic-gate * it is still associated with a section. For example, an 3397c478bd9Sstevel@tonic-gate * unknown section type (SHT_NULL) would have been rejected on 3407c478bd9Sstevel@tonic-gate * input with a warning. Here, we make the use of the symbol 3417c478bd9Sstevel@tonic-gate * fatal. A symbol descriptor is still returned, so that the 3427c478bd9Sstevel@tonic-gate * caller can continue processing all symbols, and hence flush 3437c478bd9Sstevel@tonic-gate * out as many error conditions as possible. 3447c478bd9Sstevel@tonic-gate */ 3457c478bd9Sstevel@tonic-gate if ((etype == ET_REL) && (sdp->sd_isc == 0)) { 3465aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 3475aefb655Srie MSG_INTL(MSG_SYM_INVSEC), name, ifl->ifl_name, 3485aefb655Srie EC_XWORD(shndx)); 3497c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 3507c478bd9Sstevel@tonic-gate return (sdp); 3517c478bd9Sstevel@tonic-gate } 3527c478bd9Sstevel@tonic-gate } 3537c478bd9Sstevel@tonic-gate 3547c478bd9Sstevel@tonic-gate /* 3557c478bd9Sstevel@tonic-gate * Mark any COMMON symbols as 'tentative'. 3567c478bd9Sstevel@tonic-gate */ 35754d82594Sseizo if (sdflags & FLG_SY_SPECSEC) { 3580bc07c75Srie if (nsym->st_shndx == SHN_COMMON) 35954d82594Sseizo sdp->sd_flags |= FLG_SY_TENTSYM; 36054d82594Sseizo #if (defined(__i386) || defined(__amd64)) && defined(_ELF64) 3610bc07c75Srie else if (nsym->st_shndx == SHN_X86_64_LCOMMON) 36254d82594Sseizo sdp->sd_flags |= FLG_SY_TENTSYM; 36354d82594Sseizo #endif 36454d82594Sseizo } 3657c478bd9Sstevel@tonic-gate 3667c478bd9Sstevel@tonic-gate /* 3677c478bd9Sstevel@tonic-gate * Establish the symbols reference & visibility. 3687c478bd9Sstevel@tonic-gate */ 3697c478bd9Sstevel@tonic-gate if ((etype == ET_NONE) || (etype == ET_REL)) { 3707c478bd9Sstevel@tonic-gate sdp->sd_ref = REF_REL_NEED; 3717c478bd9Sstevel@tonic-gate 3727c478bd9Sstevel@tonic-gate /* 373*9a411307Srie * Under -Bnodirect, all exported interfaces that have not 374*9a411307Srie * explicitly been defined protected or directly bound to, are 375*9a411307Srie * tagged to prevent direct binding. 3767c478bd9Sstevel@tonic-gate */ 3770bc07c75Srie if ((ofl->ofl_flags1 & FLG_OF1_ALNODIR) && 378*9a411307Srie ((sdp->sd_flags1 & (FLG_SY1_PROT | FLG_SY1_DIR)) == 0) && 379*9a411307Srie (nsym->st_shndx != SHN_UNDEF)) { 3807c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_NDIR; 381*9a411307Srie } 3827c478bd9Sstevel@tonic-gate } else { 3837c478bd9Sstevel@tonic-gate sdp->sd_ref = REF_DYN_SEEN; 3847c478bd9Sstevel@tonic-gate 3857c478bd9Sstevel@tonic-gate /* 3867c478bd9Sstevel@tonic-gate * Record the binding file for this symbol in the sa_bindto 3877c478bd9Sstevel@tonic-gate * field. If this symbol is ever overridden by a REF_REL_NEED 3887c478bd9Sstevel@tonic-gate * definition, sa_bindto is used when building a 'translator'. 3897c478bd9Sstevel@tonic-gate */ 3900bc07c75Srie if (nsym->st_shndx != SHN_UNDEF) 3917c478bd9Sstevel@tonic-gate sdp->sd_aux->sa_bindto = ifl; 3927c478bd9Sstevel@tonic-gate 3937c478bd9Sstevel@tonic-gate /* 3947c478bd9Sstevel@tonic-gate * If this is a protected symbol, mark it. 3957c478bd9Sstevel@tonic-gate */ 3967c478bd9Sstevel@tonic-gate if (ELF_ST_VISIBILITY(nsym->st_other) == STV_PROTECTED) 3977c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_PROT; 3987c478bd9Sstevel@tonic-gate 3997c478bd9Sstevel@tonic-gate /* 4007c478bd9Sstevel@tonic-gate * Mask out any visibility info from a DYN symbol. 4017c478bd9Sstevel@tonic-gate */ 4027c478bd9Sstevel@tonic-gate nsym->st_other = nsym->st_other & ~MSK_SYM_VISIBILITY; 4037c478bd9Sstevel@tonic-gate 4047c478bd9Sstevel@tonic-gate /* 4057c478bd9Sstevel@tonic-gate * If the new symbol is from a shared library and it 4067c478bd9Sstevel@tonic-gate * is associated with a SHT_NOBITS section then this 4077c478bd9Sstevel@tonic-gate * symbol originated from a tentative symbol. 4087c478bd9Sstevel@tonic-gate */ 4097c478bd9Sstevel@tonic-gate if (sdp->sd_isc && 4107c478bd9Sstevel@tonic-gate (sdp->sd_isc->is_shdr->sh_type == SHT_NOBITS)) 4117c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_TENTSYM; 4127c478bd9Sstevel@tonic-gate } 4137c478bd9Sstevel@tonic-gate 4147c478bd9Sstevel@tonic-gate /* 4157c478bd9Sstevel@tonic-gate * Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF so as to 4160bc07c75Srie * simplify future processing. 4177c478bd9Sstevel@tonic-gate */ 4180bc07c75Srie if (nsym->st_shndx == SHN_SUNW_IGNORE) { 4197c478bd9Sstevel@tonic-gate sdp->sd_shndx = shndx = SHN_UNDEF; 4207c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_REDUCED; 4217c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= 4227c478bd9Sstevel@tonic-gate (FLG_SY1_IGNORE | FLG_SY1_LOCL | FLG_SY1_ELIM); 4237c478bd9Sstevel@tonic-gate } 4247c478bd9Sstevel@tonic-gate 4257c478bd9Sstevel@tonic-gate /* 4267c478bd9Sstevel@tonic-gate * If this is an undefined, or common symbol from a relocatable object 4277c478bd9Sstevel@tonic-gate * determine whether it is a global or weak reference (see build_osym(), 4287c478bd9Sstevel@tonic-gate * where REF_DYN_NEED definitions are returned back to undefines). 4297c478bd9Sstevel@tonic-gate */ 43054d82594Sseizo if ((etype == ET_REL) && 43154d82594Sseizo (ELF_ST_BIND(nsym->st_info) == STB_GLOBAL) && 4320bc07c75Srie ((nsym->st_shndx == SHN_UNDEF) || ((sdflags & FLG_SY_SPECSEC) && 43354d82594Sseizo #if (defined(__i386) || defined(__amd64)) && defined(_ELF64) 4340bc07c75Srie ((nsym->st_shndx == SHN_COMMON) || 4350bc07c75Srie (nsym->st_shndx == SHN_X86_64_LCOMMON))))) 43654d82594Sseizo #else 4370bc07c75Srie (nsym->st_shndx == SHN_COMMON)))) 43854d82594Sseizo #endif 4397c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_GLOBREF; 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate /* 4427c478bd9Sstevel@tonic-gate * Record the input filename on the referenced or defined files list 4437c478bd9Sstevel@tonic-gate * for possible later diagnostics. The `sa_rfile' pointer contains the 4447c478bd9Sstevel@tonic-gate * name of the file that first referenced this symbol and is used to 4457c478bd9Sstevel@tonic-gate * generate undefined symbol diagnostics (refer to sym_undef_entry()). 4467c478bd9Sstevel@tonic-gate * Note that this entry can be overridden if a reference from a 4477c478bd9Sstevel@tonic-gate * relocatable object is found after a reference from a shared object 4487c478bd9Sstevel@tonic-gate * (refer to sym_override()). 4497c478bd9Sstevel@tonic-gate * The `sa_dfiles' list is used to maintain the list of files that 4507c478bd9Sstevel@tonic-gate * define the same symbol. This list can be used for two reasons: 4517c478bd9Sstevel@tonic-gate * 4527c478bd9Sstevel@tonic-gate * o To save the first definition of a symbol that is not available 4537c478bd9Sstevel@tonic-gate * for this link-edit. 4547c478bd9Sstevel@tonic-gate * 4557c478bd9Sstevel@tonic-gate * o To save all definitions of a symbol when the -m option is in 4567c478bd9Sstevel@tonic-gate * effect. This is optional as it is used to list multiple 4577c478bd9Sstevel@tonic-gate * (interposed) definitions of a symbol (refer to ldmap_out()), 4587c478bd9Sstevel@tonic-gate * and can be quite expensive. 4597c478bd9Sstevel@tonic-gate */ 4600bc07c75Srie if (nsym->st_shndx == SHN_UNDEF) { 4617c478bd9Sstevel@tonic-gate sap->sa_rfile = ifl->ifl_name; 4627c478bd9Sstevel@tonic-gate } else { 4637c478bd9Sstevel@tonic-gate if (sdp->sd_ref == REF_DYN_SEEN) { 4647c478bd9Sstevel@tonic-gate /* 4657c478bd9Sstevel@tonic-gate * A symbol is determined to be unavailable if it 4667c478bd9Sstevel@tonic-gate * belongs to a version of a shared object that this 4677c478bd9Sstevel@tonic-gate * user does not wish to use, or if it belongs to an 4687c478bd9Sstevel@tonic-gate * implicit shared object. 4697c478bd9Sstevel@tonic-gate */ 4707c478bd9Sstevel@tonic-gate if (ifl->ifl_vercnt) { 4719039eeafSab Ver_index *vip; 4727c478bd9Sstevel@tonic-gate Half vndx = ifl->ifl_versym[ndx]; 4737c478bd9Sstevel@tonic-gate 4747c478bd9Sstevel@tonic-gate sap->sa_dverndx = vndx; 4757c478bd9Sstevel@tonic-gate vip = &ifl->ifl_verndx[vndx]; 4767c478bd9Sstevel@tonic-gate if (!(vip->vi_flags & FLG_VER_AVAIL)) { 4777c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_NOTAVAIL; 4787c478bd9Sstevel@tonic-gate sap->sa_vfile = ifl->ifl_name; 4797c478bd9Sstevel@tonic-gate } 4807c478bd9Sstevel@tonic-gate } 4817c478bd9Sstevel@tonic-gate if (!(ifl->ifl_flags & FLG_IF_NEEDED)) 4827c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_NOTAVAIL; 4837c478bd9Sstevel@tonic-gate 4847c478bd9Sstevel@tonic-gate } else if (etype == ET_REL) { 4857c478bd9Sstevel@tonic-gate /* 4867c478bd9Sstevel@tonic-gate * If this symbol has been obtained from a versioned 4877c478bd9Sstevel@tonic-gate * input relocatable object then the new symbol must be 4887c478bd9Sstevel@tonic-gate * promoted to the versioning of the output file. 4897c478bd9Sstevel@tonic-gate */ 4907c478bd9Sstevel@tonic-gate if (ifl->ifl_versym) 4915aefb655Srie ld_vers_promote(sdp, ndx, ifl, ofl); 4927c478bd9Sstevel@tonic-gate } 4937c478bd9Sstevel@tonic-gate 4947c478bd9Sstevel@tonic-gate if ((ofl->ofl_flags & FLG_OF_GENMAP) && 4957c478bd9Sstevel@tonic-gate ((sdflags & FLG_SY_SPECSEC) == 0)) 4967c478bd9Sstevel@tonic-gate if (list_appendc(&sap->sa_dfiles, ifl->ifl_name) == 0) 4977c478bd9Sstevel@tonic-gate return ((Sym_desc *)S_ERROR); 4987c478bd9Sstevel@tonic-gate } 4997c478bd9Sstevel@tonic-gate 5005aefb655Srie DBG_CALL(Dbg_syms_entered(ofl, nsym, sdp)); 5017c478bd9Sstevel@tonic-gate return (sdp); 5027c478bd9Sstevel@tonic-gate } 5037c478bd9Sstevel@tonic-gate 5047c478bd9Sstevel@tonic-gate /* 5057c478bd9Sstevel@tonic-gate * Add a special symbol to the symbol table. Takes special symbol name with 5067c478bd9Sstevel@tonic-gate * and without underscores. This routine is called, after all other symbol 5077c478bd9Sstevel@tonic-gate * resolution has completed, to generate a reserved absolute symbol (the 5087c478bd9Sstevel@tonic-gate * underscore version). Special symbols are updated with the appropriate 509dd94ecefSrie * values in update_osym(). If the user has already defined this symbol 5107c478bd9Sstevel@tonic-gate * issue a warning and leave the symbol as is. If the non-underscore symbol 5117c478bd9Sstevel@tonic-gate * is referenced then turn it into a weak alias of the underscored symbol. 5127c478bd9Sstevel@tonic-gate * 5137c478bd9Sstevel@tonic-gate * If this is a global symbol, and it hasn't explicitly been defined as being 5147c478bd9Sstevel@tonic-gate * directly bound to, indicate that it can't be directly bound to. 5157c478bd9Sstevel@tonic-gate * Historically, most special symbols only have meaning to the object in which 516c1c6f601Srie * they exist, however, they've always been global. To ensure compatibility 517c1c6f601Srie * with any unexpected use presently in effect, ensure these symbols don't get 5187c478bd9Sstevel@tonic-gate * directly bound to. Note, that establishing this state here isn't sufficient 5197c478bd9Sstevel@tonic-gate * to create a syminfo table, only if a syminfo table is being created by some 520c1c6f601Srie * other symbol directives will the nodirect binding be recorded. This ensures 5217c478bd9Sstevel@tonic-gate * we don't create syminfo sections for all objects we create, as this might add 5227c478bd9Sstevel@tonic-gate * unnecessary bloat to users who haven't explicitly requested extra symbol 5237c478bd9Sstevel@tonic-gate * information. 5247c478bd9Sstevel@tonic-gate */ 5257c478bd9Sstevel@tonic-gate static uintptr_t 5267c478bd9Sstevel@tonic-gate sym_add_spec(const char *name, const char *uname, Word sdaux_id, 5277c478bd9Sstevel@tonic-gate Half flags1, Ofl_desc *ofl) 5287c478bd9Sstevel@tonic-gate { 5297c478bd9Sstevel@tonic-gate Sym_desc *sdp; 5307c478bd9Sstevel@tonic-gate Sym_desc *usdp; 5317c478bd9Sstevel@tonic-gate Sym *sym; 5327c478bd9Sstevel@tonic-gate Word hash; 5337c478bd9Sstevel@tonic-gate avl_index_t where; 5347c478bd9Sstevel@tonic-gate 5357c478bd9Sstevel@tonic-gate /* LINTED */ 5367c478bd9Sstevel@tonic-gate hash = (Word)elf_hash(uname); 5375aefb655Srie if (usdp = ld_sym_find(uname, hash, &where, ofl)) { 5387c478bd9Sstevel@tonic-gate /* 5397c478bd9Sstevel@tonic-gate * If the underscore symbol exists and is undefined, or was 5407c478bd9Sstevel@tonic-gate * defined in a shared library, convert it to a local symbol. 5417c478bd9Sstevel@tonic-gate * Otherwise leave it as is and warn the user. 5427c478bd9Sstevel@tonic-gate */ 5437c478bd9Sstevel@tonic-gate if ((usdp->sd_shndx == SHN_UNDEF) || 5447c478bd9Sstevel@tonic-gate (usdp->sd_ref != REF_REL_NEED)) { 5457c478bd9Sstevel@tonic-gate usdp->sd_ref = REF_REL_NEED; 5467c478bd9Sstevel@tonic-gate usdp->sd_shndx = usdp->sd_sym->st_shndx = SHN_ABS; 5477c478bd9Sstevel@tonic-gate usdp->sd_flags |= FLG_SY_SPECSEC; 5487c478bd9Sstevel@tonic-gate usdp->sd_sym->st_info = 5497c478bd9Sstevel@tonic-gate ELF_ST_INFO(STB_GLOBAL, STT_OBJECT); 5507c478bd9Sstevel@tonic-gate usdp->sd_isc = NULL; 5517c478bd9Sstevel@tonic-gate usdp->sd_sym->st_size = 0; 5527c478bd9Sstevel@tonic-gate usdp->sd_sym->st_value = 0; 5537c478bd9Sstevel@tonic-gate /* LINTED */ 5547c478bd9Sstevel@tonic-gate usdp->sd_aux->sa_symspec = (Half)sdaux_id; 5557c478bd9Sstevel@tonic-gate 5567c478bd9Sstevel@tonic-gate /* 557*9a411307Srie * If a user hasn't specifically indicated that the 558*9a411307Srie * scope of this symbol be made local, then leave it 559*9a411307Srie * as global (ie. prevent automatic scoping). The GOT 560*9a411307Srie * should be defined protected, whereas all other 561*9a411307Srie * special symbols are tagged as no-direct. 5627c478bd9Sstevel@tonic-gate */ 5637c478bd9Sstevel@tonic-gate if (!(usdp->sd_flags1 & FLG_SY1_LOCL) && 5647c478bd9Sstevel@tonic-gate (flags1 & FLG_SY1_GLOB)) { 565*9a411307Srie usdp->sd_aux->sa_overndx = VER_NDX_GLOBAL; 566*9a411307Srie if (sdaux_id == SDAUX_ID_GOT) { 567*9a411307Srie usdp->sd_flags1 &= ~FLG_SY1_NDIR; 568*9a411307Srie usdp->sd_flags1 |= FLG_SY1_PROT; 569*9a411307Srie usdp->sd_sym->st_other = STV_PROTECTED; 570*9a411307Srie } else if (((usdp->sd_flags1 & FLG_SY1_DIR) == 0) && 571*9a411307Srie ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) { 572*9a411307Srie usdp->sd_flags1 |= FLG_SY1_NDIR; 573*9a411307Srie } 5747c478bd9Sstevel@tonic-gate } 5757c478bd9Sstevel@tonic-gate usdp->sd_flags1 |= flags1; 5767c478bd9Sstevel@tonic-gate 5777c478bd9Sstevel@tonic-gate /* 578c1c6f601Srie * If the reference originated from a mapfile ensure 5797c478bd9Sstevel@tonic-gate * we mark the symbol as used. 5807c478bd9Sstevel@tonic-gate */ 5817c478bd9Sstevel@tonic-gate if (usdp->sd_flags & FLG_SY_MAPREF) 5827c478bd9Sstevel@tonic-gate usdp->sd_flags |= FLG_SY_MAPUSED; 5837c478bd9Sstevel@tonic-gate 5845aefb655Srie DBG_CALL(Dbg_syms_updated(ofl, usdp, uname)); 5857c478bd9Sstevel@tonic-gate } else 5865aefb655Srie eprintf(ofl->ofl_lml, ERR_WARNING, 5875aefb655Srie MSG_INTL(MSG_SYM_RESERVE), uname, 5887c478bd9Sstevel@tonic-gate usdp->sd_file->ifl_name); 5897c478bd9Sstevel@tonic-gate } else { 5907c478bd9Sstevel@tonic-gate /* 5917c478bd9Sstevel@tonic-gate * If the symbol does not exist create it. 5927c478bd9Sstevel@tonic-gate */ 5937c478bd9Sstevel@tonic-gate if ((sym = libld_calloc(sizeof (Sym), 1)) == 0) 5947c478bd9Sstevel@tonic-gate return (S_ERROR); 5957c478bd9Sstevel@tonic-gate sym->st_shndx = SHN_ABS; 5967c478bd9Sstevel@tonic-gate sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_OBJECT); 5977c478bd9Sstevel@tonic-gate sym->st_size = 0; 5987c478bd9Sstevel@tonic-gate sym->st_value = 0; 5995aefb655Srie DBG_CALL(Dbg_syms_created(ofl->ofl_lml, uname)); 6005aefb655Srie if ((usdp = ld_sym_enter(uname, sym, hash, (Ifl_desc *)NULL, 6017c478bd9Sstevel@tonic-gate ofl, 0, SHN_ABS, FLG_SY_SPECSEC, 0, &where)) == 6027c478bd9Sstevel@tonic-gate (Sym_desc *)S_ERROR) 6037c478bd9Sstevel@tonic-gate return (S_ERROR); 6047c478bd9Sstevel@tonic-gate usdp->sd_ref = REF_REL_NEED; 6057c478bd9Sstevel@tonic-gate /* LINTED */ 6067c478bd9Sstevel@tonic-gate usdp->sd_aux->sa_symspec = (Half)sdaux_id; 6077c478bd9Sstevel@tonic-gate 6087c478bd9Sstevel@tonic-gate usdp->sd_aux->sa_overndx = VER_NDX_GLOBAL; 609*9a411307Srie 610*9a411307Srie if (sdaux_id == SDAUX_ID_GOT) { 611*9a411307Srie usdp->sd_flags1 |= FLG_SY1_PROT; 612*9a411307Srie usdp->sd_sym->st_other = STV_PROTECTED; 613*9a411307Srie } else if ((flags1 & FLG_SY1_GLOB) && 614*9a411307Srie ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) { 6157c478bd9Sstevel@tonic-gate usdp->sd_flags1 |= FLG_SY1_NDIR; 616*9a411307Srie } 6177c478bd9Sstevel@tonic-gate usdp->sd_flags1 |= flags1; 6187c478bd9Sstevel@tonic-gate } 6197c478bd9Sstevel@tonic-gate 6205aefb655Srie if (name && (sdp = ld_sym_find(name, SYM_NOHASH, 0, ofl)) && 6210bc07c75Srie (sdp->sd_sym->st_shndx == SHN_UNDEF)) { 6227c478bd9Sstevel@tonic-gate uchar_t bind; 6237c478bd9Sstevel@tonic-gate 6247c478bd9Sstevel@tonic-gate /* 6257c478bd9Sstevel@tonic-gate * If the non-underscore symbol exists and is undefined 6267c478bd9Sstevel@tonic-gate * convert it to be a local. If the underscore has 6277c478bd9Sstevel@tonic-gate * sa_symspec set (ie. it was created above) then simulate this 6287c478bd9Sstevel@tonic-gate * as a weak alias. 6297c478bd9Sstevel@tonic-gate */ 6307c478bd9Sstevel@tonic-gate sdp->sd_ref = REF_REL_NEED; 6317c478bd9Sstevel@tonic-gate sdp->sd_shndx = sdp->sd_sym->st_shndx = SHN_ABS; 6327c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_SPECSEC; 6337c478bd9Sstevel@tonic-gate sdp->sd_isc = NULL; 6347c478bd9Sstevel@tonic-gate sdp->sd_sym->st_size = 0; 6357c478bd9Sstevel@tonic-gate sdp->sd_sym->st_value = 0; 6367c478bd9Sstevel@tonic-gate /* LINTED */ 6377c478bd9Sstevel@tonic-gate sdp->sd_aux->sa_symspec = (Half)sdaux_id; 6387c478bd9Sstevel@tonic-gate if (usdp->sd_aux->sa_symspec) { 6397c478bd9Sstevel@tonic-gate usdp->sd_aux->sa_linkndx = 0; 6407c478bd9Sstevel@tonic-gate sdp->sd_aux->sa_linkndx = 0; 6417c478bd9Sstevel@tonic-gate bind = STB_WEAK; 6427c478bd9Sstevel@tonic-gate } else 6437c478bd9Sstevel@tonic-gate bind = STB_GLOBAL; 6447c478bd9Sstevel@tonic-gate sdp->sd_sym->st_info = ELF_ST_INFO(bind, STT_OBJECT); 6457c478bd9Sstevel@tonic-gate 6467c478bd9Sstevel@tonic-gate /* 647*9a411307Srie * If a user hasn't specifically indicated the scope of this 648*9a411307Srie * symbol be made local then leave it as global (ie. prevent 649*9a411307Srie * automatic scoping). The GOT should be defined protected, 650*9a411307Srie * whereas all other special symbols are tagged as no-direct. 6517c478bd9Sstevel@tonic-gate */ 6527c478bd9Sstevel@tonic-gate if (!(sdp->sd_flags1 & FLG_SY1_LOCL) && 6537c478bd9Sstevel@tonic-gate (flags1 & FLG_SY1_GLOB)) { 6547c478bd9Sstevel@tonic-gate sdp->sd_aux->sa_overndx = VER_NDX_GLOBAL; 655*9a411307Srie if (sdaux_id == SDAUX_ID_GOT) { 656*9a411307Srie sdp->sd_flags1 &= ~FLG_SY1_NDIR; 657*9a411307Srie sdp->sd_flags1 |= FLG_SY1_PROT; 658*9a411307Srie sdp->sd_sym->st_other = STV_PROTECTED; 659*9a411307Srie } else if (((sdp->sd_flags1 & FLG_SY1_DIR) == 0) && 660*9a411307Srie ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) { 6617c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_NDIR; 662*9a411307Srie } 6637c478bd9Sstevel@tonic-gate } 6647c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= flags1; 6657c478bd9Sstevel@tonic-gate 6667c478bd9Sstevel@tonic-gate /* 667c1c6f601Srie * If the reference originated from a mapfile ensure 6687c478bd9Sstevel@tonic-gate * we mark the symbol as used. 6697c478bd9Sstevel@tonic-gate */ 6707c478bd9Sstevel@tonic-gate if (sdp->sd_flags & FLG_SY_MAPREF) 6717c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_MAPUSED; 6727c478bd9Sstevel@tonic-gate 6735aefb655Srie DBG_CALL(Dbg_syms_updated(ofl, sdp, name)); 6747c478bd9Sstevel@tonic-gate } 6757c478bd9Sstevel@tonic-gate return (1); 6767c478bd9Sstevel@tonic-gate } 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate 6797c478bd9Sstevel@tonic-gate /* 6807c478bd9Sstevel@tonic-gate * Print undefined symbols. 6817c478bd9Sstevel@tonic-gate */ 6827c478bd9Sstevel@tonic-gate static Boolean undef_title = TRUE; 6837c478bd9Sstevel@tonic-gate 6845aefb655Srie static void 6855aefb655Srie sym_undef_title(Ofl_desc *ofl) 6867c478bd9Sstevel@tonic-gate { 6875aefb655Srie eprintf(ofl->ofl_lml, ERR_NONE, MSG_INTL(MSG_SYM_FMT_UNDEF), 6887c478bd9Sstevel@tonic-gate MSG_INTL(MSG_SYM_UNDEF_ITM_11), 6897c478bd9Sstevel@tonic-gate MSG_INTL(MSG_SYM_UNDEF_ITM_21), 6907c478bd9Sstevel@tonic-gate MSG_INTL(MSG_SYM_UNDEF_ITM_12), 6917c478bd9Sstevel@tonic-gate MSG_INTL(MSG_SYM_UNDEF_ITM_22)); 6927c478bd9Sstevel@tonic-gate 6937c478bd9Sstevel@tonic-gate undef_title = FALSE; 6947c478bd9Sstevel@tonic-gate } 6957c478bd9Sstevel@tonic-gate 6967c478bd9Sstevel@tonic-gate /* 6977c478bd9Sstevel@tonic-gate * Undefined symbols can fall into one of four types: 6987c478bd9Sstevel@tonic-gate * 6997c478bd9Sstevel@tonic-gate * o the symbol is really undefined (SHN_UNDEF). 7007c478bd9Sstevel@tonic-gate * 7017c478bd9Sstevel@tonic-gate * o versioning has been enabled, however this symbol has not been assigned 7027c478bd9Sstevel@tonic-gate * to one of the defined versions. 7037c478bd9Sstevel@tonic-gate * 7047c478bd9Sstevel@tonic-gate * o the symbol has been defined by an implicitly supplied library, ie. one 7057c478bd9Sstevel@tonic-gate * which was encounted because it was NEEDED by another library, rather 7067c478bd9Sstevel@tonic-gate * than from a command line supplied library which would become the only 7077c478bd9Sstevel@tonic-gate * dependency of the output file being produced. 7087c478bd9Sstevel@tonic-gate * 7097c478bd9Sstevel@tonic-gate * o the symbol has been defined by a version of a shared object that is 7107c478bd9Sstevel@tonic-gate * not permitted for this link-edit. 7117c478bd9Sstevel@tonic-gate * 7127c478bd9Sstevel@tonic-gate * In all cases the file who made the first reference to this symbol will have 7137c478bd9Sstevel@tonic-gate * been recorded via the `sa_rfile' pointer. 7147c478bd9Sstevel@tonic-gate */ 7157c478bd9Sstevel@tonic-gate typedef enum { 7167c478bd9Sstevel@tonic-gate UNDEF, NOVERSION, IMPLICIT, NOTAVAIL, 7177c478bd9Sstevel@tonic-gate BNDLOCAL 7187c478bd9Sstevel@tonic-gate } Type; 7197c478bd9Sstevel@tonic-gate 7207c478bd9Sstevel@tonic-gate static const Msg format[] = { 7217c478bd9Sstevel@tonic-gate MSG_SYM_UND_UNDEF, /* MSG_INTL(MSG_SYM_UND_UNDEF) */ 7227c478bd9Sstevel@tonic-gate MSG_SYM_UND_NOVER, /* MSG_INTL(MSG_SYM_UND_NOVER) */ 7237c478bd9Sstevel@tonic-gate MSG_SYM_UND_IMPL, /* MSG_INTL(MSG_SYM_UND_IMPL) */ 7247c478bd9Sstevel@tonic-gate MSG_SYM_UND_NOTA, /* MSG_INTL(MSG_SYM_UND_NOTA) */ 7257c478bd9Sstevel@tonic-gate MSG_SYM_UND_BNDLOCAL /* MSG_INTL(MSG_SYM_UND_BNDLOCAL) */ 7267c478bd9Sstevel@tonic-gate }; 7277c478bd9Sstevel@tonic-gate 7285aefb655Srie static void 7295aefb655Srie sym_undef_entry(Ofl_desc *ofl, Sym_desc *sdp, Type type) 7307c478bd9Sstevel@tonic-gate { 7317c478bd9Sstevel@tonic-gate const char *name1, *name2, *name3; 7327c478bd9Sstevel@tonic-gate Ifl_desc *ifl = sdp->sd_file; 7337c478bd9Sstevel@tonic-gate Sym_aux *sap = sdp->sd_aux; 7347c478bd9Sstevel@tonic-gate 7357c478bd9Sstevel@tonic-gate if (undef_title) 7365aefb655Srie sym_undef_title(ofl); 7377c478bd9Sstevel@tonic-gate 7387c478bd9Sstevel@tonic-gate switch (type) { 7397c478bd9Sstevel@tonic-gate case UNDEF: 7407c478bd9Sstevel@tonic-gate case BNDLOCAL: 7417c478bd9Sstevel@tonic-gate name1 = sap->sa_rfile; 7427c478bd9Sstevel@tonic-gate break; 7437c478bd9Sstevel@tonic-gate case NOVERSION: 7447c478bd9Sstevel@tonic-gate name1 = ifl->ifl_name; 7457c478bd9Sstevel@tonic-gate break; 7467c478bd9Sstevel@tonic-gate case IMPLICIT: 7477c478bd9Sstevel@tonic-gate name1 = sap->sa_rfile; 7487c478bd9Sstevel@tonic-gate name2 = ifl->ifl_name; 7497c478bd9Sstevel@tonic-gate break; 7507c478bd9Sstevel@tonic-gate case NOTAVAIL: 7517c478bd9Sstevel@tonic-gate name1 = sap->sa_rfile; 7527c478bd9Sstevel@tonic-gate name2 = sap->sa_vfile; 7537c478bd9Sstevel@tonic-gate name3 = ifl->ifl_verndx[sap->sa_dverndx].vi_name; 7547c478bd9Sstevel@tonic-gate break; 7557c478bd9Sstevel@tonic-gate default: 7567c478bd9Sstevel@tonic-gate return; 7577c478bd9Sstevel@tonic-gate } 7587c478bd9Sstevel@tonic-gate 7595aefb655Srie eprintf(ofl->ofl_lml, ERR_NONE, MSG_INTL(format[type]), 7605aefb655Srie demangle(sdp->sd_name), name1, name2, name3); 7617c478bd9Sstevel@tonic-gate } 7627c478bd9Sstevel@tonic-gate 7637c478bd9Sstevel@tonic-gate /* 7647c478bd9Sstevel@tonic-gate * At this point all symbol input processing has been completed, therefore 7657c478bd9Sstevel@tonic-gate * complete the symbol table entries by generating any necessary internal 7667c478bd9Sstevel@tonic-gate * symbols. 7677c478bd9Sstevel@tonic-gate */ 7687c478bd9Sstevel@tonic-gate uintptr_t 7695aefb655Srie ld_sym_spec(Ofl_desc *ofl) 7707c478bd9Sstevel@tonic-gate { 771*9a411307Srie Sym_desc *sdp; 7727c478bd9Sstevel@tonic-gate 773*9a411307Srie if (ofl->ofl_flags & FLG_OF_RELOBJ) 774*9a411307Srie return (1); 7757c478bd9Sstevel@tonic-gate 776*9a411307Srie DBG_CALL(Dbg_syms_spec_title(ofl->ofl_lml)); 777*9a411307Srie 778*9a411307Srie if (sym_add_spec(MSG_ORIG(MSG_SYM_ETEXT), MSG_ORIG(MSG_SYM_ETEXT_U), 779*9a411307Srie SDAUX_ID_ETEXT, FLG_SY1_GLOB, ofl) == S_ERROR) 780*9a411307Srie return (S_ERROR); 781*9a411307Srie if (sym_add_spec(MSG_ORIG(MSG_SYM_EDATA), MSG_ORIG(MSG_SYM_EDATA_U), 782*9a411307Srie SDAUX_ID_EDATA, FLG_SY1_GLOB, ofl) == S_ERROR) 783*9a411307Srie return (S_ERROR); 784*9a411307Srie if (sym_add_spec(MSG_ORIG(MSG_SYM_END), MSG_ORIG(MSG_SYM_END_U), 785*9a411307Srie SDAUX_ID_END, FLG_SY1_GLOB, ofl) == S_ERROR) 786*9a411307Srie return (S_ERROR); 787*9a411307Srie if (sym_add_spec(MSG_ORIG(MSG_SYM_L_END), MSG_ORIG(MSG_SYM_L_END_U), 788*9a411307Srie SDAUX_ID_END, FLG_SY1_LOCL, ofl) == S_ERROR) 789*9a411307Srie return (S_ERROR); 790*9a411307Srie if (sym_add_spec(MSG_ORIG(MSG_SYM_L_START), MSG_ORIG(MSG_SYM_L_START_U), 791*9a411307Srie SDAUX_ID_START, FLG_SY1_LOCL, ofl) == S_ERROR) 792*9a411307Srie return (S_ERROR); 7937c478bd9Sstevel@tonic-gate 794*9a411307Srie /* 795*9a411307Srie * Historically we've always produced a _DYNAMIC symbol, even for 796*9a411307Srie * static executables (in which case its value will be 0). 797*9a411307Srie */ 798*9a411307Srie if (sym_add_spec(MSG_ORIG(MSG_SYM_DYNAMIC), MSG_ORIG(MSG_SYM_DYNAMIC_U), 799*9a411307Srie SDAUX_ID_DYN, FLG_SY1_GLOB, ofl) == S_ERROR) 800*9a411307Srie return (S_ERROR); 801*9a411307Srie 802*9a411307Srie if (OFL_ALLOW_DYNSYM(ofl)) { 803*9a411307Srie if (sym_add_spec(MSG_ORIG(MSG_SYM_PLKTBL), 804*9a411307Srie MSG_ORIG(MSG_SYM_PLKTBL_U), SDAUX_ID_PLT, 8057c478bd9Sstevel@tonic-gate FLG_SY1_GLOB, ofl) == S_ERROR) 8067c478bd9Sstevel@tonic-gate return (S_ERROR); 807*9a411307Srie } 8087c478bd9Sstevel@tonic-gate 809*9a411307Srie /* 810*9a411307Srie * A GOT reference will be accompanied by the associated GOT symbol. 811*9a411307Srie * Make sure it gets assigned the appropriate special attributes. 812*9a411307Srie */ 813*9a411307Srie if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_GOFTBL_U), 814*9a411307Srie SYM_NOHASH, 0, ofl)) != 0) && (sdp->sd_ref != REF_DYN_SEEN)) { 815*9a411307Srie if (sym_add_spec(MSG_ORIG(MSG_SYM_GOFTBL), 816*9a411307Srie MSG_ORIG(MSG_SYM_GOFTBL_U), SDAUX_ID_GOT, FLG_SY1_GLOB, 817*9a411307Srie ofl) == S_ERROR) 818*9a411307Srie return (S_ERROR); 8197c478bd9Sstevel@tonic-gate } 820*9a411307Srie 8217c478bd9Sstevel@tonic-gate return (1); 8227c478bd9Sstevel@tonic-gate } 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate /* 8257c478bd9Sstevel@tonic-gate * This routine checks to see if a symbols visibility needs to be reduced to 8267c478bd9Sstevel@tonic-gate * either SYMBOLIC or LOCAL. This routine can be called from either 8277c478bd9Sstevel@tonic-gate * reloc_init() or sym_validate(). 8287c478bd9Sstevel@tonic-gate */ 8297c478bd9Sstevel@tonic-gate void 8305aefb655Srie ld_sym_adjust_vis(Sym_desc *sdp, Ofl_desc *ofl) 8317c478bd9Sstevel@tonic-gate { 8327c478bd9Sstevel@tonic-gate Word symvis, oflags = ofl->ofl_flags, oflags1 = ofl->ofl_flags1; 8337c478bd9Sstevel@tonic-gate Sym *sym = sdp->sd_sym; 8347c478bd9Sstevel@tonic-gate 8350bc07c75Srie if ((sdp->sd_ref == REF_REL_NEED) && 8360bc07c75Srie (sdp->sd_sym->st_shndx != SHN_UNDEF)) { 8377c478bd9Sstevel@tonic-gate /* 8387c478bd9Sstevel@tonic-gate * If scoping is enabled, reduce any nonversioned global 8397c478bd9Sstevel@tonic-gate * symbols (any symbol that has been processed for relocations 8407c478bd9Sstevel@tonic-gate * will have already had this same reduction test applied). 8417c478bd9Sstevel@tonic-gate * Indicate that the symbol has been reduced as it may be 8427c478bd9Sstevel@tonic-gate * necessary to print these symbols later. 8437c478bd9Sstevel@tonic-gate */ 8447c478bd9Sstevel@tonic-gate if (((oflags & FLG_OF_AUTOLCL) || 8457c478bd9Sstevel@tonic-gate (oflags1 & FLG_OF1_AUTOELM)) && 8467c478bd9Sstevel@tonic-gate ((sdp->sd_flags1 & MSK_SY1_DEFINED) == 0)) { 8477c478bd9Sstevel@tonic-gate 8487c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_REDUCED; 8497c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_LOCL; 8507c478bd9Sstevel@tonic-gate 8517c478bd9Sstevel@tonic-gate if (ELF_ST_VISIBILITY(sym->st_other) != STV_INTERNAL) 8527c478bd9Sstevel@tonic-gate sym->st_other = STV_HIDDEN | 8537c478bd9Sstevel@tonic-gate (sym->st_other & ~MSK_SYM_VISIBILITY); 8547c478bd9Sstevel@tonic-gate 8557c478bd9Sstevel@tonic-gate if (ofl->ofl_flags1 & 8567c478bd9Sstevel@tonic-gate (FLG_OF1_REDLSYM | FLG_OF1_AUTOELM)) 8577c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_ELIM; 8587c478bd9Sstevel@tonic-gate } 8597c478bd9Sstevel@tonic-gate 8607c478bd9Sstevel@tonic-gate /* 861*9a411307Srie * If -Bsymbolic is in effect, and the symbol hasn't explicitly 862*9a411307Srie * been defined nodirect (via a mapfile), then bind the global 863*9a411307Srie * symbol symbolically and assign the STV_PROTECTED visibility 8647c478bd9Sstevel@tonic-gate * attribute. 8657c478bd9Sstevel@tonic-gate */ 8667c478bd9Sstevel@tonic-gate if ((oflags & FLG_OF_SYMBOLIC) && 867*9a411307Srie ((sdp->sd_flags1 & (FLG_SY1_LOCL | FLG_SY1_NDIR)) == 0)) { 8687c478bd9Sstevel@tonic-gate 8697c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_PROT; 8707c478bd9Sstevel@tonic-gate if (ELF_ST_VISIBILITY(sym->st_other) == STV_DEFAULT) 8717c478bd9Sstevel@tonic-gate sym->st_other = STV_PROTECTED | 8727c478bd9Sstevel@tonic-gate (sym->st_other & ~MSK_SYM_VISIBILITY); 8737c478bd9Sstevel@tonic-gate } 8747c478bd9Sstevel@tonic-gate } 8757c478bd9Sstevel@tonic-gate 8767c478bd9Sstevel@tonic-gate /* 8777c478bd9Sstevel@tonic-gate * Check to see if the symbol visibility needs to be adjusted due to any 8787c478bd9Sstevel@tonic-gate * STV_* symbol attributes being set. 8797c478bd9Sstevel@tonic-gate * 8807c478bd9Sstevel@tonic-gate * STV_PROTECTED == symbolic binding 8817c478bd9Sstevel@tonic-gate * STV_INTERNAL == reduce to local 8827c478bd9Sstevel@tonic-gate * STV_HIDDEN == reduce to local 8837c478bd9Sstevel@tonic-gate * 8847c478bd9Sstevel@tonic-gate * Note, UNDEF symbols can be assigned a visibility, thus the refencing 8857c478bd9Sstevel@tonic-gate * code can be dependent on this visibility. Here, by only ignoring 8867c478bd9Sstevel@tonic-gate * REF_DYN_SEEN symbol definitions we can be assigning a visibility to 8877c478bd9Sstevel@tonic-gate * REF_DYN_NEED. If the protected, or local assignment is made to 8887c478bd9Sstevel@tonic-gate * a REF_DYN_NEED symbol, it will be caught later as an illegal 8897c478bd9Sstevel@tonic-gate * visibility. 8907c478bd9Sstevel@tonic-gate */ 8917c478bd9Sstevel@tonic-gate if (!(oflags & FLG_OF_RELOBJ) && (sdp->sd_ref != REF_DYN_SEEN) && 8927c478bd9Sstevel@tonic-gate (symvis = ELF_ST_VISIBILITY(sym->st_other))) { 8937c478bd9Sstevel@tonic-gate if (symvis == STV_PROTECTED) 8947c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_PROT; 8957c478bd9Sstevel@tonic-gate else if ((symvis == STV_INTERNAL) || (symvis == STV_HIDDEN)) 8967c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_LOCL; 8977c478bd9Sstevel@tonic-gate } 8987c478bd9Sstevel@tonic-gate 8997c478bd9Sstevel@tonic-gate /* 9007c478bd9Sstevel@tonic-gate * Indicate that this symbol has had it's visibility checked so that 9017c478bd9Sstevel@tonic-gate * we don't need to do this investigation again. 9027c478bd9Sstevel@tonic-gate */ 9037c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_VISIBLE; 9047c478bd9Sstevel@tonic-gate } 9057c478bd9Sstevel@tonic-gate 906c1c6f601Srie /* 907c1c6f601Srie * Make sure a symbol definition is local to the object being built. 908c1c6f601Srie */ 909c1c6f601Srie static int 910c1c6f601Srie ensure_sym_local(Ofl_desc *ofl, Sym_desc *sdp, const char *str) 911c1c6f601Srie { 912c1c6f601Srie if (sdp->sd_sym->st_shndx == SHN_UNDEF) { 913c1c6f601Srie if (str) { 914c1c6f601Srie eprintf(ofl->ofl_lml, ERR_FATAL, 915c1c6f601Srie MSG_INTL(MSG_SYM_UNDEF), str, 916c1c6f601Srie demangle((char *)sdp->sd_name)); 917c1c6f601Srie } 918c1c6f601Srie return (1); 919c1c6f601Srie } 920c1c6f601Srie if (sdp->sd_ref != REF_REL_NEED) { 921c1c6f601Srie if (str) { 922c1c6f601Srie eprintf(ofl->ofl_lml, ERR_FATAL, 923c1c6f601Srie MSG_INTL(MSG_SYM_EXTERN), str, 924c1c6f601Srie demangle((char *)sdp->sd_name), 925c1c6f601Srie sdp->sd_file->ifl_name); 926c1c6f601Srie } 927c1c6f601Srie return (1); 928c1c6f601Srie } 929c1c6f601Srie 930c1c6f601Srie sdp->sd_flags |= FLG_SY_UPREQD; 931c1c6f601Srie if (sdp->sd_isc) { 932c1c6f601Srie sdp->sd_isc->is_flags |= FLG_IS_SECTREF; 933c1c6f601Srie sdp->sd_isc->is_file->ifl_flags |= FLG_IF_FILEREF; 934c1c6f601Srie } 935c1c6f601Srie return (0); 936c1c6f601Srie } 937c1c6f601Srie 938c1c6f601Srie /* 939c1c6f601Srie * Make sure all the symbol definitions required for initarray, finiarray, or 940c1c6f601Srie * preinitarray's are local to the object being built. 941c1c6f601Srie */ 942c1c6f601Srie static int 943c1c6f601Srie ensure_array_local(Ofl_desc *ofl, List *list, const char *str) 944c1c6f601Srie { 945c1c6f601Srie Listnode *lnp; 946c1c6f601Srie Sym_desc *sdp; 947c1c6f601Srie int ret = 0; 948c1c6f601Srie 949c1c6f601Srie for (LIST_TRAVERSE(list, lnp, sdp)) 950c1c6f601Srie ret += ensure_sym_local(ofl, sdp, str); 951c1c6f601Srie 952c1c6f601Srie return (ret); 953c1c6f601Srie } 954c1c6f601Srie 9557c478bd9Sstevel@tonic-gate /* 9567c478bd9Sstevel@tonic-gate * After all symbol table input processing has been finished, and all relocation 9577c478bd9Sstevel@tonic-gate * counting has been carried out (ie. no more symbols will be read, generated, 9587c478bd9Sstevel@tonic-gate * or modified), validate and count the relevant entries: 9597c478bd9Sstevel@tonic-gate * 9607c478bd9Sstevel@tonic-gate * o check and print any undefined symbols remaining. Note that 9617c478bd9Sstevel@tonic-gate * if a symbol has been defined by virtue of the inclusion of 9627c478bd9Sstevel@tonic-gate * an implicit shared library, it is still classed as undefined. 9637c478bd9Sstevel@tonic-gate * 9647c478bd9Sstevel@tonic-gate * o count the number of global needed symbols together with the 9657c478bd9Sstevel@tonic-gate * size of their associated name strings (if scoping has been 9667c478bd9Sstevel@tonic-gate * indicated these symbols may be reduced to locals). 9677c478bd9Sstevel@tonic-gate * 9687c478bd9Sstevel@tonic-gate * o establish the size and alignment requirements for the global 9697c478bd9Sstevel@tonic-gate * .bss section (the alignment of this section is based on the 9707c478bd9Sstevel@tonic-gate * first symbol that it will contain). 9717c478bd9Sstevel@tonic-gate */ 9727c478bd9Sstevel@tonic-gate uintptr_t 9735aefb655Srie ld_sym_validate(Ofl_desc *ofl) 9747c478bd9Sstevel@tonic-gate { 9757c478bd9Sstevel@tonic-gate Sym_avlnode *sav; 9767c478bd9Sstevel@tonic-gate Sym_desc *sdp; 9777c478bd9Sstevel@tonic-gate Sym *sym; 9787c478bd9Sstevel@tonic-gate Word oflags = ofl->ofl_flags; 9797c478bd9Sstevel@tonic-gate Word undef = 0, needed = 0, verdesc = 0; 9807c478bd9Sstevel@tonic-gate Xword bssalign = 0, tlsalign = 0; 9817c478bd9Sstevel@tonic-gate Xword bsssize = 0, tlssize = 0; 98254d82594Sseizo #if (defined(__i386) || defined(__amd64)) && defined(_ELF64) 98354d82594Sseizo Xword lbssalign = 0, lbsssize = 0; 98454d82594Sseizo #endif 985c1c6f601Srie int ret; 9869039eeafSab int allow_ldynsym; 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate /* 9897c478bd9Sstevel@tonic-gate * If a symbol is undefined and this link-edit calls for no undefined 9907c478bd9Sstevel@tonic-gate * symbols to remain (this is the default case when generating an 9917c478bd9Sstevel@tonic-gate * executable but can be enforced for any object using -z defs), the 9927c478bd9Sstevel@tonic-gate * symbol is classified as undefined and a fatal error condition will 9937c478bd9Sstevel@tonic-gate * be indicated. 9947c478bd9Sstevel@tonic-gate * 9957c478bd9Sstevel@tonic-gate * If the symbol is undefined and we're creating a shared object with 9967c478bd9Sstevel@tonic-gate * the -Bsymbolic flag, then the symbol is also classified as undefined 9977c478bd9Sstevel@tonic-gate * and a warning condition will be indicated. 9987c478bd9Sstevel@tonic-gate */ 9997c478bd9Sstevel@tonic-gate if ((oflags & (FLG_OF_SHAROBJ | FLG_OF_SYMBOLIC)) == 10007c478bd9Sstevel@tonic-gate (FLG_OF_SHAROBJ | FLG_OF_SYMBOLIC)) 10017c478bd9Sstevel@tonic-gate undef = FLG_OF_WARN; 10027c478bd9Sstevel@tonic-gate if (oflags & FLG_OF_NOUNDEF) 10037c478bd9Sstevel@tonic-gate undef = FLG_OF_FATAL; 10047c478bd9Sstevel@tonic-gate 10057c478bd9Sstevel@tonic-gate /* 10067c478bd9Sstevel@tonic-gate * If the symbol is referenced from an implicitly included shared object 10077c478bd9Sstevel@tonic-gate * (ie. it's not on the NEEDED list) then the symbol is also classified 10087c478bd9Sstevel@tonic-gate * as undefined and a fatal error condition will be indicated. 10097c478bd9Sstevel@tonic-gate */ 10107c478bd9Sstevel@tonic-gate if ((oflags & FLG_OF_NOUNDEF) || !(oflags & FLG_OF_SHAROBJ)) 10117c478bd9Sstevel@tonic-gate needed = FLG_OF_FATAL; 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate /* 10147c478bd9Sstevel@tonic-gate * If the output image is being versioned all symbol definitions must be 10157c478bd9Sstevel@tonic-gate * associated with a version. Any symbol that isn't is classified as 10167c478bd9Sstevel@tonic-gate * undefined and a fatal error condition will be indicated. 10177c478bd9Sstevel@tonic-gate */ 10187c478bd9Sstevel@tonic-gate if ((oflags & FLG_OF_VERDEF) && (ofl->ofl_vercnt > VER_NDX_GLOBAL)) 10197c478bd9Sstevel@tonic-gate verdesc = FLG_OF_FATAL; 10207c478bd9Sstevel@tonic-gate 10219039eeafSab allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl); 10227c478bd9Sstevel@tonic-gate /* 10237c478bd9Sstevel@tonic-gate * Collect and validate the globals from the internal symbol table. 10247c478bd9Sstevel@tonic-gate */ 10257c478bd9Sstevel@tonic-gate for (sav = avl_first(&ofl->ofl_symavl); sav; 10267c478bd9Sstevel@tonic-gate sav = AVL_NEXT(&ofl->ofl_symavl, sav)) { 10277c478bd9Sstevel@tonic-gate Is_desc * isp; 10280bc07c75Srie int undeferr = 0; 10297c478bd9Sstevel@tonic-gate 10307c478bd9Sstevel@tonic-gate sdp = sav->sav_symdesc; 10317c478bd9Sstevel@tonic-gate 10327c478bd9Sstevel@tonic-gate /* 10337c478bd9Sstevel@tonic-gate * If undefined symbols are allowed ignore any symbols that are 10347c478bd9Sstevel@tonic-gate * not needed. 10357c478bd9Sstevel@tonic-gate */ 10367c478bd9Sstevel@tonic-gate if (!(oflags & FLG_OF_NOUNDEF) && 10377c478bd9Sstevel@tonic-gate (sdp->sd_ref == REF_DYN_SEEN)) 10387c478bd9Sstevel@tonic-gate continue; 10397c478bd9Sstevel@tonic-gate 10407c478bd9Sstevel@tonic-gate /* 10417c478bd9Sstevel@tonic-gate * If the symbol originates from an external or parent mapfile 10427c478bd9Sstevel@tonic-gate * reference and hasn't been matched to a reference from a 10437c478bd9Sstevel@tonic-gate * relocatable object, ignore it. 10447c478bd9Sstevel@tonic-gate */ 10457c478bd9Sstevel@tonic-gate if ((sdp->sd_flags & (FLG_SY_EXTERN | FLG_SY_PARENT)) && 10467c478bd9Sstevel@tonic-gate ((sdp->sd_flags & FLG_SY_MAPUSED) == 0)) { 10477c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_INVALID; 10487c478bd9Sstevel@tonic-gate continue; 10497c478bd9Sstevel@tonic-gate } 10507c478bd9Sstevel@tonic-gate 10517c478bd9Sstevel@tonic-gate sym = sdp->sd_sym; 10527c478bd9Sstevel@tonic-gate 10537c478bd9Sstevel@tonic-gate /* 10547c478bd9Sstevel@tonic-gate * Sanity check TLS. 10557c478bd9Sstevel@tonic-gate */ 10567c478bd9Sstevel@tonic-gate if ((ELF_ST_TYPE(sym->st_info) == STT_TLS) && 10570bc07c75Srie (sym->st_size != 0) && (sym->st_shndx != SHN_UNDEF) && 10580bc07c75Srie (sym->st_shndx != SHN_COMMON)) { 10597c478bd9Sstevel@tonic-gate Is_desc * isp = sdp->sd_isc; 10607c478bd9Sstevel@tonic-gate Ifl_desc * ifl = sdp->sd_file; 10617c478bd9Sstevel@tonic-gate 10627c478bd9Sstevel@tonic-gate if ((isp == 0) || (isp->is_shdr == 0) || 10637c478bd9Sstevel@tonic-gate ((isp->is_shdr->sh_flags & SHF_TLS) == 0)) { 10645aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 10655aefb655Srie MSG_INTL(MSG_SYM_TLS), 10667c478bd9Sstevel@tonic-gate demangle(sdp->sd_name), ifl->ifl_name); 10677c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 10687c478bd9Sstevel@tonic-gate continue; 10697c478bd9Sstevel@tonic-gate } 10707c478bd9Sstevel@tonic-gate } 10717c478bd9Sstevel@tonic-gate 10727c478bd9Sstevel@tonic-gate if ((sdp->sd_flags & FLG_SY_VISIBLE) == 0) 10735aefb655Srie ld_sym_adjust_vis(sdp, ofl); 10747c478bd9Sstevel@tonic-gate 10757c478bd9Sstevel@tonic-gate if ((sdp->sd_flags & FLG_SY_REDUCED) && 10767c478bd9Sstevel@tonic-gate (oflags & FLG_OF_PROCRED)) { 10775aefb655Srie DBG_CALL(Dbg_syms_reduce(ofl, DBG_SYM_REDUCE_GLOBAL, 10785aefb655Srie sdp, 0, 0)); 10797c478bd9Sstevel@tonic-gate } 10807c478bd9Sstevel@tonic-gate 10817c478bd9Sstevel@tonic-gate /* 10827c478bd9Sstevel@tonic-gate * If building a shared object or executable, and this is a 10837c478bd9Sstevel@tonic-gate * non-weak UNDEF symbol with reduced visibility (STV_*), then 10847c478bd9Sstevel@tonic-gate * give a fatal error. 10857c478bd9Sstevel@tonic-gate */ 10867c478bd9Sstevel@tonic-gate if (!(oflags & FLG_OF_RELOBJ) && 10870bc07c75Srie ELF_ST_VISIBILITY(sym->st_other) && 10880bc07c75Srie (sym->st_shndx == SHN_UNDEF) && 10897c478bd9Sstevel@tonic-gate (ELF_ST_BIND(sym->st_info) != STB_WEAK)) { 10905aefb655Srie sym_undef_entry(ofl, sdp, BNDLOCAL); 10917c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 10927c478bd9Sstevel@tonic-gate continue; 10937c478bd9Sstevel@tonic-gate } 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate /* 10967c478bd9Sstevel@tonic-gate * If this symbol is defined in a non-allocatable section, 10977c478bd9Sstevel@tonic-gate * reduce it to local symbol. 10987c478bd9Sstevel@tonic-gate */ 10997c478bd9Sstevel@tonic-gate if (((isp = sdp->sd_isc) != 0) && isp->is_shdr && 11007c478bd9Sstevel@tonic-gate ((isp->is_shdr->sh_flags & SHF_ALLOC) == 0)) { 11017c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_REDUCED; 11027c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_LOCL; 11037c478bd9Sstevel@tonic-gate } 11047c478bd9Sstevel@tonic-gate 11057c478bd9Sstevel@tonic-gate /* 11067c478bd9Sstevel@tonic-gate * If this symbol originated as a SHN_SUNW_IGNORE, it will have 11077c478bd9Sstevel@tonic-gate * been processed as an SHN_UNDEF. Return the symbol to its 11087c478bd9Sstevel@tonic-gate * original index for validation, and propagation to the output 11097c478bd9Sstevel@tonic-gate * file. 11107c478bd9Sstevel@tonic-gate */ 11117c478bd9Sstevel@tonic-gate if (sdp->sd_flags1 & FLG_SY1_IGNORE) 11120bc07c75Srie sdp->sd_shndx = SHN_SUNW_IGNORE; 11137c478bd9Sstevel@tonic-gate 11147c478bd9Sstevel@tonic-gate if (undef) { 11157c478bd9Sstevel@tonic-gate /* 11167c478bd9Sstevel@tonic-gate * If an non-weak reference remains undefined, or if a 11177c478bd9Sstevel@tonic-gate * mapfile reference is not bound to the relocatable 11187c478bd9Sstevel@tonic-gate * objects that make up the object being built, we have 11197c478bd9Sstevel@tonic-gate * a fatal error. 11207c478bd9Sstevel@tonic-gate * 11217c478bd9Sstevel@tonic-gate * The exceptions are symbols which are defined to be 11227c478bd9Sstevel@tonic-gate * found in the parent (FLG_SY_PARENT), which is really 11237c478bd9Sstevel@tonic-gate * only meaningful for direct binding, or are defined 11247c478bd9Sstevel@tonic-gate * external (FLG_SY_EXTERN) so as to suppress -zdefs 11257c478bd9Sstevel@tonic-gate * errors. 11267c478bd9Sstevel@tonic-gate * 11277c478bd9Sstevel@tonic-gate * Register symbols are always allowed to be UNDEF. 11287c478bd9Sstevel@tonic-gate * 11297c478bd9Sstevel@tonic-gate * Note that we don't include references created via -u 11307c478bd9Sstevel@tonic-gate * in the same shared object binding test. This is for 11317c478bd9Sstevel@tonic-gate * backward compatibility, in that a number of archive 11327c478bd9Sstevel@tonic-gate * makefile rules used -u to cause archive extraction. 11337c478bd9Sstevel@tonic-gate * These same rules have been cut and pasted to apply 11347c478bd9Sstevel@tonic-gate * to shared objects, and thus although the -u reference 11357c478bd9Sstevel@tonic-gate * is redundant, flagging it as fatal could cause some 11367c478bd9Sstevel@tonic-gate * build to fail. Also we have documented the use of 11377c478bd9Sstevel@tonic-gate * -u as a mechanism to cause binding to weak version 11387c478bd9Sstevel@tonic-gate * definitions, thus giving users an error condition 11397c478bd9Sstevel@tonic-gate * would be incorrect. 11407c478bd9Sstevel@tonic-gate */ 11417c478bd9Sstevel@tonic-gate if (!(sdp->sd_flags & FLG_SY_REGSYM) && 11420bc07c75Srie ((sym->st_shndx == SHN_UNDEF) && 11437c478bd9Sstevel@tonic-gate ((ELF_ST_BIND(sym->st_info) != STB_WEAK) && 11447c478bd9Sstevel@tonic-gate ((sdp->sd_flags & 11457c478bd9Sstevel@tonic-gate (FLG_SY_PARENT | FLG_SY_EXTERN)) == 0)) || 11467c478bd9Sstevel@tonic-gate (((sdp->sd_flags & 11477c478bd9Sstevel@tonic-gate (FLG_SY_MAPREF | FLG_SY_MAPUSED)) == 11487c478bd9Sstevel@tonic-gate FLG_SY_MAPREF) && 11497c478bd9Sstevel@tonic-gate ((sdp->sd_flags1 & (FLG_SY1_LOCL | 11507c478bd9Sstevel@tonic-gate FLG_SY1_PROT)) == 0)))) { 11515aefb655Srie sym_undef_entry(ofl, sdp, UNDEF); 11527c478bd9Sstevel@tonic-gate ofl->ofl_flags |= undef; 11537c478bd9Sstevel@tonic-gate undeferr = 1; 11547c478bd9Sstevel@tonic-gate } 11557c478bd9Sstevel@tonic-gate 11567c478bd9Sstevel@tonic-gate } else { 11577c478bd9Sstevel@tonic-gate /* 11587c478bd9Sstevel@tonic-gate * For building things like shared objects (or anything 11597c478bd9Sstevel@tonic-gate * -znodefs), undefined symbols are allowed. 11607c478bd9Sstevel@tonic-gate * 11617c478bd9Sstevel@tonic-gate * If a mapfile reference remains undefined the user 11627c478bd9Sstevel@tonic-gate * would probably like a warning at least (they've 11637c478bd9Sstevel@tonic-gate * usually mis-spelt the reference). Refer to the above 11647c478bd9Sstevel@tonic-gate * comments for discussion on -u references, which 11657c478bd9Sstevel@tonic-gate * are not tested for in the same manner. 11667c478bd9Sstevel@tonic-gate */ 11677c478bd9Sstevel@tonic-gate if ((sdp->sd_flags & 11687c478bd9Sstevel@tonic-gate (FLG_SY_MAPREF | FLG_SY_MAPUSED)) == 11697c478bd9Sstevel@tonic-gate FLG_SY_MAPREF) { 11705aefb655Srie sym_undef_entry(ofl, sdp, UNDEF); 11717c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_WARN; 11727c478bd9Sstevel@tonic-gate undeferr = 1; 11737c478bd9Sstevel@tonic-gate } 11747c478bd9Sstevel@tonic-gate } 11757c478bd9Sstevel@tonic-gate 11767c478bd9Sstevel@tonic-gate /* 11777c478bd9Sstevel@tonic-gate * If this symbol comes from a dependency mark the dependency 11787c478bd9Sstevel@tonic-gate * as required (-z ignore can result in unused dependencies 11797c478bd9Sstevel@tonic-gate * being dropped). If we need to record dependency versioning 11807c478bd9Sstevel@tonic-gate * information indicate what version of the needed shared object 11817c478bd9Sstevel@tonic-gate * this symbol is part of. Flag the symbol as undefined if it 11827c478bd9Sstevel@tonic-gate * has not been made available to us. 11837c478bd9Sstevel@tonic-gate */ 11847c478bd9Sstevel@tonic-gate if ((sdp->sd_ref == REF_DYN_NEED) && 11857c478bd9Sstevel@tonic-gate (!(sdp->sd_flags & FLG_SY_REFRSD))) { 11867c478bd9Sstevel@tonic-gate sdp->sd_file->ifl_flags |= FLG_IF_DEPREQD; 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate /* 11897c478bd9Sstevel@tonic-gate * Capture that we've bound to a symbol that doesn't 11907c478bd9Sstevel@tonic-gate * allow being directly bound to. 11917c478bd9Sstevel@tonic-gate */ 11927c478bd9Sstevel@tonic-gate if (sdp->sd_flags1 & FLG_SY1_NDIR) 11937c478bd9Sstevel@tonic-gate ofl->ofl_flags1 |= FLG_OF1_NDIRECT; 11947c478bd9Sstevel@tonic-gate 11957c478bd9Sstevel@tonic-gate if (sdp->sd_file->ifl_vercnt) { 11967c478bd9Sstevel@tonic-gate int vndx; 11977c478bd9Sstevel@tonic-gate Ver_index * vip; 11987c478bd9Sstevel@tonic-gate 11997c478bd9Sstevel@tonic-gate vndx = sdp->sd_aux->sa_dverndx; 12007c478bd9Sstevel@tonic-gate vip = &sdp->sd_file->ifl_verndx[vndx]; 12017c478bd9Sstevel@tonic-gate if (vip->vi_flags & FLG_VER_AVAIL) { 12027c478bd9Sstevel@tonic-gate vip->vi_flags |= FLG_VER_REFER; 12037c478bd9Sstevel@tonic-gate } else { 12045aefb655Srie sym_undef_entry(ofl, sdp, NOTAVAIL); 12057c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 12067c478bd9Sstevel@tonic-gate continue; 12077c478bd9Sstevel@tonic-gate } 12087c478bd9Sstevel@tonic-gate } 12097c478bd9Sstevel@tonic-gate } 12107c478bd9Sstevel@tonic-gate 12117c478bd9Sstevel@tonic-gate /* 12127c478bd9Sstevel@tonic-gate * Test that we do not bind to symbol supplied from an implicit 12137c478bd9Sstevel@tonic-gate * shared object. If a binding is from a weak reference it can 12147c478bd9Sstevel@tonic-gate * be ignored. 12157c478bd9Sstevel@tonic-gate */ 12167c478bd9Sstevel@tonic-gate if (needed && !undeferr && (sdp->sd_flags & FLG_SY_GLOBREF) && 12177c478bd9Sstevel@tonic-gate (sdp->sd_ref == REF_DYN_NEED) && 12187c478bd9Sstevel@tonic-gate (sdp->sd_flags & FLG_SY_NOTAVAIL)) { 12195aefb655Srie sym_undef_entry(ofl, sdp, IMPLICIT); 12207c478bd9Sstevel@tonic-gate ofl->ofl_flags |= needed; 12217c478bd9Sstevel@tonic-gate continue; 12227c478bd9Sstevel@tonic-gate } 12237c478bd9Sstevel@tonic-gate 12247c478bd9Sstevel@tonic-gate /* 12257c478bd9Sstevel@tonic-gate * Test that a symbol isn't going to be reduced to local scope 12267c478bd9Sstevel@tonic-gate * which actually wants to bind to a shared object - if so it's 12277c478bd9Sstevel@tonic-gate * a fatal error. 12287c478bd9Sstevel@tonic-gate */ 12297c478bd9Sstevel@tonic-gate if ((sdp->sd_ref == REF_DYN_NEED) && 12307c478bd9Sstevel@tonic-gate (sdp->sd_flags1 & (FLG_SY1_LOCL | FLG_SY1_PROT))) { 12315aefb655Srie sym_undef_entry(ofl, sdp, BNDLOCAL); 12327c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 12337c478bd9Sstevel@tonic-gate continue; 12347c478bd9Sstevel@tonic-gate } 12357c478bd9Sstevel@tonic-gate 12367c478bd9Sstevel@tonic-gate /* 12377c478bd9Sstevel@tonic-gate * If the output image is to be versioned then all symbol 12387c478bd9Sstevel@tonic-gate * definitions must be associated with a version. 12397c478bd9Sstevel@tonic-gate */ 12407c478bd9Sstevel@tonic-gate if (verdesc && (sdp->sd_ref == REF_REL_NEED) && 12410bc07c75Srie (sym->st_shndx != SHN_UNDEF) && 12427c478bd9Sstevel@tonic-gate (!(sdp->sd_flags1 & FLG_SY1_LOCL)) && 12437c478bd9Sstevel@tonic-gate (sdp->sd_aux->sa_overndx == 0)) { 12445aefb655Srie sym_undef_entry(ofl, sdp, NOVERSION); 12457c478bd9Sstevel@tonic-gate ofl->ofl_flags |= verdesc; 12467c478bd9Sstevel@tonic-gate continue; 12477c478bd9Sstevel@tonic-gate } 12487c478bd9Sstevel@tonic-gate 12497c478bd9Sstevel@tonic-gate /* 12507c478bd9Sstevel@tonic-gate * If we don't need the symbol there's no need to process it 12517c478bd9Sstevel@tonic-gate * any further. 12527c478bd9Sstevel@tonic-gate */ 12537c478bd9Sstevel@tonic-gate if (sdp->sd_ref == REF_DYN_SEEN) 12547c478bd9Sstevel@tonic-gate continue; 12557c478bd9Sstevel@tonic-gate 12567c478bd9Sstevel@tonic-gate /* 12577c478bd9Sstevel@tonic-gate * Calculate the size and alignment requirements for the global 12587c478bd9Sstevel@tonic-gate * .bss and .tls sections. If we're building a relocatable 12597c478bd9Sstevel@tonic-gate * object only account for scoped COMMON symbols (these will 12607c478bd9Sstevel@tonic-gate * be converted to .bss references). 12617c478bd9Sstevel@tonic-gate * 12627c478bd9Sstevel@tonic-gate * For partially initialized symbol, 12637c478bd9Sstevel@tonic-gate * if it is expanded, it goes to sunwdata1. 12647c478bd9Sstevel@tonic-gate * if it is local, it goes to .bss. 12657c478bd9Sstevel@tonic-gate * if the output is shared object, it goes to .sunwbss. 12667c478bd9Sstevel@tonic-gate * 12677c478bd9Sstevel@tonic-gate * Also refer to make_mvsections() in sunwmove.c 12687c478bd9Sstevel@tonic-gate */ 12690bc07c75Srie if ((sym->st_shndx == SHN_COMMON) && 12700bc07c75Srie (((oflags & FLG_OF_RELOBJ) == 0) || 12717c478bd9Sstevel@tonic-gate ((sdp->sd_flags1 & FLG_SY1_LOCL) && 12727c478bd9Sstevel@tonic-gate (oflags & FLG_OF_PROCRED)))) { 12737c478bd9Sstevel@tonic-gate int countbss = 0; 12747c478bd9Sstevel@tonic-gate 12757c478bd9Sstevel@tonic-gate if (sdp->sd_psyminfo == 0) { 12767c478bd9Sstevel@tonic-gate countbss = 1; 12777c478bd9Sstevel@tonic-gate } else if ((sdp->sd_flags & FLG_SY_PAREXPN) != 0) { 12787c478bd9Sstevel@tonic-gate countbss = 0; 12797c478bd9Sstevel@tonic-gate } else if (ELF_ST_BIND(sym->st_info) == STB_LOCAL) { 12807c478bd9Sstevel@tonic-gate countbss = 1; 12817c478bd9Sstevel@tonic-gate } else if ((ofl->ofl_flags & FLG_OF_SHAROBJ) != 0) { 12827c478bd9Sstevel@tonic-gate countbss = 0; 12837c478bd9Sstevel@tonic-gate } else 12847c478bd9Sstevel@tonic-gate countbss = 1; 12857c478bd9Sstevel@tonic-gate 12867c478bd9Sstevel@tonic-gate if (countbss) { 12877c478bd9Sstevel@tonic-gate Xword * size, * align; 12887c478bd9Sstevel@tonic-gate 12897c478bd9Sstevel@tonic-gate if (ELF_ST_TYPE(sym->st_info) != STT_TLS) { 12907c478bd9Sstevel@tonic-gate size = &bsssize; 12917c478bd9Sstevel@tonic-gate align = &bssalign; 12927c478bd9Sstevel@tonic-gate } else { 12937c478bd9Sstevel@tonic-gate size = &tlssize; 12947c478bd9Sstevel@tonic-gate align = &tlsalign; 12957c478bd9Sstevel@tonic-gate } 12967c478bd9Sstevel@tonic-gate *size = (Xword)S_ROUND(*size, sym->st_value) + 1297dd94ecefSrie sym->st_size; 12987c478bd9Sstevel@tonic-gate if (sym->st_value > *align) 12997c478bd9Sstevel@tonic-gate *align = sym->st_value; 13007c478bd9Sstevel@tonic-gate } 13017c478bd9Sstevel@tonic-gate } 13027c478bd9Sstevel@tonic-gate 130354d82594Sseizo #if (defined(__i386) || defined(__amd64)) && defined(_ELF64) 130454d82594Sseizo /* 130554d82594Sseizo * Calculate the size and alignment requirement for the global 130654d82594Sseizo * .lbss. TLS or partially initialized symbols do not need to be 130754d82594Sseizo * considered yet. 130854d82594Sseizo */ 13090bc07c75Srie if (sym->st_shndx == SHN_X86_64_LCOMMON) { 131054d82594Sseizo lbsssize = (Xword)S_ROUND(lbsssize, sym->st_value) + 131154d82594Sseizo sym->st_size; 131254d82594Sseizo if (sym->st_value > lbssalign) 131354d82594Sseizo lbssalign = sym->st_value; 131454d82594Sseizo } 131554d82594Sseizo #endif 131654d82594Sseizo 13177c478bd9Sstevel@tonic-gate /* 13187c478bd9Sstevel@tonic-gate * If a symbol was referenced via the command line 13197c478bd9Sstevel@tonic-gate * (ld -u <>, ...), then this counts as a reference against the 13207c478bd9Sstevel@tonic-gate * symbol. Mark any section that symbol is defined in. 13217c478bd9Sstevel@tonic-gate */ 13227c478bd9Sstevel@tonic-gate if (((isp = sdp->sd_isc) != 0) && 13237c478bd9Sstevel@tonic-gate (sdp->sd_flags & FLG_SY_CMDREF)) { 13247c478bd9Sstevel@tonic-gate isp->is_flags |= FLG_IS_SECTREF; 13257c478bd9Sstevel@tonic-gate isp->is_file->ifl_flags |= FLG_IF_FILEREF; 13267c478bd9Sstevel@tonic-gate } 13277c478bd9Sstevel@tonic-gate 13287c478bd9Sstevel@tonic-gate /* 13297c478bd9Sstevel@tonic-gate * Update the symbol count and the associated name string size. 13307c478bd9Sstevel@tonic-gate * If scoping is in effect for this symbol assign it will be 13317c478bd9Sstevel@tonic-gate * assigned to the .symtab/.strtab sections. 13327c478bd9Sstevel@tonic-gate */ 13337c478bd9Sstevel@tonic-gate if ((sdp->sd_flags1 & FLG_SY1_LOCL) && 13347c478bd9Sstevel@tonic-gate (oflags & FLG_OF_PROCRED)) { 13357c478bd9Sstevel@tonic-gate /* 13367c478bd9Sstevel@tonic-gate * If symbol gets eliminated count it. 13377c478bd9Sstevel@tonic-gate * 13387c478bd9Sstevel@tonic-gate * If symbol gets reduced to local, 13397c478bd9Sstevel@tonic-gate * count it's size for the .symtab. 13407c478bd9Sstevel@tonic-gate */ 13417c478bd9Sstevel@tonic-gate if (sdp->sd_flags1 & FLG_SY1_ELIM) { 13427c478bd9Sstevel@tonic-gate ofl->ofl_elimcnt++; 13437c478bd9Sstevel@tonic-gate } else { 13447c478bd9Sstevel@tonic-gate ofl->ofl_scopecnt++; 13457c478bd9Sstevel@tonic-gate if ((((sdp->sd_flags & FLG_SY_REGSYM) == 0) || 13467c478bd9Sstevel@tonic-gate sym->st_name) && (st_insert(ofl->ofl_strtab, 13477c478bd9Sstevel@tonic-gate sdp->sd_name) == -1)) 13487c478bd9Sstevel@tonic-gate return (S_ERROR); 13499039eeafSab if (allow_ldynsym && sym->st_name && 13509039eeafSab (ELF_ST_TYPE(sym->st_info) == STT_FUNC)) { 13519039eeafSab ofl->ofl_dynscopecnt++; 13529039eeafSab if (st_insert(ofl->ofl_dynstrtab, 13539039eeafSab sdp->sd_name) == -1) 13549039eeafSab return (S_ERROR); 13559039eeafSab } 13567c478bd9Sstevel@tonic-gate } 13577c478bd9Sstevel@tonic-gate } else { 13587c478bd9Sstevel@tonic-gate ofl->ofl_globcnt++; 13597c478bd9Sstevel@tonic-gate 13607c478bd9Sstevel@tonic-gate /* 13617c478bd9Sstevel@tonic-gate * If global direct bindings are in effect, or this 13627c478bd9Sstevel@tonic-gate * symbol has bound to a dependency which was specified 13637c478bd9Sstevel@tonic-gate * as requiring direct bindings, and it hasn't 13647c478bd9Sstevel@tonic-gate * explicitly been defined as a non-direct binding 13657c478bd9Sstevel@tonic-gate * symbol, mark it. 13667c478bd9Sstevel@tonic-gate */ 13677c478bd9Sstevel@tonic-gate if (((ofl->ofl_dtflags_1 & DF_1_DIRECT) || (isp && 13687c478bd9Sstevel@tonic-gate (isp->is_file->ifl_flags & FLG_IF_DIRECT))) && 13697c478bd9Sstevel@tonic-gate ((sdp->sd_flags1 & FLG_SY1_NDIR) == 0)) 13707c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_DIR; 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate /* 13737c478bd9Sstevel@tonic-gate * Insert the symbol name. 13747c478bd9Sstevel@tonic-gate */ 13757c478bd9Sstevel@tonic-gate if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) || 13767c478bd9Sstevel@tonic-gate sym->st_name) { 13777c478bd9Sstevel@tonic-gate if (st_insert(ofl->ofl_strtab, 13787c478bd9Sstevel@tonic-gate sdp->sd_name) == -1) 13797c478bd9Sstevel@tonic-gate return (S_ERROR); 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate if (!(ofl->ofl_flags & FLG_OF_RELOBJ) && 13827c478bd9Sstevel@tonic-gate (st_insert(ofl->ofl_dynstrtab, 13837c478bd9Sstevel@tonic-gate sdp->sd_name) == -1)) 13847c478bd9Sstevel@tonic-gate return (S_ERROR); 13857c478bd9Sstevel@tonic-gate } 13867c478bd9Sstevel@tonic-gate 13877c478bd9Sstevel@tonic-gate /* 13887c478bd9Sstevel@tonic-gate * If this section offers a global symbol - record that 13897c478bd9Sstevel@tonic-gate * fact. 13907c478bd9Sstevel@tonic-gate */ 13917c478bd9Sstevel@tonic-gate if (isp) { 13927c478bd9Sstevel@tonic-gate isp->is_flags |= FLG_IS_SECTREF; 13937c478bd9Sstevel@tonic-gate isp->is_file->ifl_flags |= FLG_IF_FILEREF; 13947c478bd9Sstevel@tonic-gate } 13957c478bd9Sstevel@tonic-gate } 13967c478bd9Sstevel@tonic-gate } 13977c478bd9Sstevel@tonic-gate 13987c478bd9Sstevel@tonic-gate /* 13997c478bd9Sstevel@tonic-gate * If we've encountered a fatal error during symbol validation then 14007c478bd9Sstevel@tonic-gate * return now. 14017c478bd9Sstevel@tonic-gate */ 14027c478bd9Sstevel@tonic-gate if (ofl->ofl_flags & FLG_OF_FATAL) 14037c478bd9Sstevel@tonic-gate return (1); 14047c478bd9Sstevel@tonic-gate 14057c478bd9Sstevel@tonic-gate /* 14067c478bd9Sstevel@tonic-gate * Now that symbol resolution is completed, scan any register symbols. 14077c478bd9Sstevel@tonic-gate * From now on, we're only interested in those that contribute to the 14087c478bd9Sstevel@tonic-gate * output file. 14097c478bd9Sstevel@tonic-gate */ 14107c478bd9Sstevel@tonic-gate if (ofl->ofl_regsyms) { 14117c478bd9Sstevel@tonic-gate int ndx; 14127c478bd9Sstevel@tonic-gate 14137c478bd9Sstevel@tonic-gate for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) { 14147c478bd9Sstevel@tonic-gate if ((sdp = ofl->ofl_regsyms[ndx]) == 0) 14157c478bd9Sstevel@tonic-gate continue; 14167c478bd9Sstevel@tonic-gate if (sdp->sd_ref != REF_REL_NEED) { 14177c478bd9Sstevel@tonic-gate ofl->ofl_regsyms[ndx] = 0; 14187c478bd9Sstevel@tonic-gate continue; 14197c478bd9Sstevel@tonic-gate } 14207c478bd9Sstevel@tonic-gate 14217c478bd9Sstevel@tonic-gate ofl->ofl_regsymcnt++; 14227c478bd9Sstevel@tonic-gate if (sdp->sd_sym->st_name == 0) 14237c478bd9Sstevel@tonic-gate sdp->sd_name = MSG_ORIG(MSG_STR_EMPTY); 14247c478bd9Sstevel@tonic-gate 14257c478bd9Sstevel@tonic-gate if ((sdp->sd_flags1 & FLG_SY1_LOCL) || 14267c478bd9Sstevel@tonic-gate (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL)) 14277c478bd9Sstevel@tonic-gate ofl->ofl_lregsymcnt++; 14287c478bd9Sstevel@tonic-gate } 14297c478bd9Sstevel@tonic-gate } 14307c478bd9Sstevel@tonic-gate 14317c478bd9Sstevel@tonic-gate /* 14327c478bd9Sstevel@tonic-gate * Generate the .bss section now that we know its size and alignment. 14337c478bd9Sstevel@tonic-gate */ 14347c478bd9Sstevel@tonic-gate if (bsssize || !(oflags & FLG_OF_RELOBJ)) { 14355aefb655Srie if (ld_make_bss(ofl, bsssize, bssalign, MAKE_BSS) == S_ERROR) 14367c478bd9Sstevel@tonic-gate return (S_ERROR); 14377c478bd9Sstevel@tonic-gate } 14387c478bd9Sstevel@tonic-gate if (tlssize) { 14395aefb655Srie if (ld_make_bss(ofl, tlssize, tlsalign, MAKE_TLS) == S_ERROR) 144054d82594Sseizo return (S_ERROR); 144154d82594Sseizo } 144254d82594Sseizo #if (defined(__i386) || defined(__amd64)) && defined(_ELF64) 144354d82594Sseizo if (lbsssize && !(oflags & FLG_OF_RELOBJ)) { 14445aefb655Srie if (ld_make_bss(ofl, lbsssize, lbssalign, MAKE_LBSS) == S_ERROR) 14457c478bd9Sstevel@tonic-gate return (S_ERROR); 14467c478bd9Sstevel@tonic-gate } 144754d82594Sseizo #endif 14487c478bd9Sstevel@tonic-gate 14497c478bd9Sstevel@tonic-gate /* 14507c478bd9Sstevel@tonic-gate * Determine what entry point symbol we need, and if found save its 14517c478bd9Sstevel@tonic-gate * symbol descriptor so that we can update the ELF header entry with the 14527c478bd9Sstevel@tonic-gate * symbols value later (see update_oehdr). Make sure the symbol is 1453c1c6f601Srie * tagged to ensure its update in case -s is in effect. Use any -e 14547c478bd9Sstevel@tonic-gate * option first, or the default entry points `_start' and `main'. 14557c478bd9Sstevel@tonic-gate */ 1456c1c6f601Srie ret = 0; 14577c478bd9Sstevel@tonic-gate if (ofl->ofl_entry) { 1458c1c6f601Srie if (((sdp = ld_sym_find(ofl->ofl_entry, SYM_NOHASH, 0, 1459c1c6f601Srie ofl)) != NULL) && (ensure_sym_local(ofl, 1460c1c6f601Srie sdp, MSG_INTL(MSG_SYM_ENTRY)) == 0)) { 1461c1c6f601Srie ofl->ofl_entry = (void *)sdp; 1462c1c6f601Srie } else { 1463c1c6f601Srie ret++; 14647c478bd9Sstevel@tonic-gate } 14655aefb655Srie } else if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_START), 1466c1c6f601Srie SYM_NOHASH, 0, ofl)) != NULL) && (ensure_sym_local(ofl, 1467c1c6f601Srie sdp, 0) == 0)) { 14687c478bd9Sstevel@tonic-gate ofl->ofl_entry = (void *)sdp; 1469c1c6f601Srie 14705aefb655Srie } else if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_MAIN), 1471c1c6f601Srie SYM_NOHASH, 0, ofl)) != NULL) && (ensure_sym_local(ofl, 1472c1c6f601Srie sdp, 0) == 0)) { 14737c478bd9Sstevel@tonic-gate ofl->ofl_entry = (void *)sdp; 14747c478bd9Sstevel@tonic-gate } 14757c478bd9Sstevel@tonic-gate 14767c478bd9Sstevel@tonic-gate /* 1477c1c6f601Srie * If ld -zdtrace=<sym> was given, then validate that the symbol is 1478c1c6f601Srie * defined within the current object being built. 14797c478bd9Sstevel@tonic-gate */ 14807c478bd9Sstevel@tonic-gate if ((sdp = ofl->ofl_dtracesym) != 0) { 1481c1c6f601Srie ret += ensure_sym_local(ofl, sdp, MSG_ORIG(MSG_STR_DTRACE)); 14827c478bd9Sstevel@tonic-gate } 14837c478bd9Sstevel@tonic-gate 1484c1c6f601Srie /* 1485c1c6f601Srie * If any initarray, finiarray or preinitarray functions have been 1486c1c6f601Srie * requested, make sure they are defined within the current object 1487c1c6f601Srie * being built. 1488c1c6f601Srie */ 1489c1c6f601Srie if (ofl->ofl_initarray.head) { 1490c1c6f601Srie ret += ensure_array_local(ofl, &ofl->ofl_initarray, 1491c1c6f601Srie MSG_ORIG(MSG_SYM_INITARRAY)); 1492c1c6f601Srie } 1493c1c6f601Srie if (ofl->ofl_finiarray.head) { 1494c1c6f601Srie ret += ensure_array_local(ofl, &ofl->ofl_finiarray, 1495c1c6f601Srie MSG_ORIG(MSG_SYM_FINIARRAY)); 1496c1c6f601Srie } 1497c1c6f601Srie if (ofl->ofl_preiarray.head) { 1498c1c6f601Srie ret += ensure_array_local(ofl, &ofl->ofl_preiarray, 1499c1c6f601Srie MSG_ORIG(MSG_SYM_PREINITARRAY)); 1500c1c6f601Srie } 1501c1c6f601Srie 1502c1c6f601Srie if (ret) 1503c1c6f601Srie return (S_ERROR); 1504c1c6f601Srie 15057c478bd9Sstevel@tonic-gate /* 15067c478bd9Sstevel@tonic-gate * If we're required to record any needed dependencies versioning 15077c478bd9Sstevel@tonic-gate * information calculate it now that all symbols have been validated. 15087c478bd9Sstevel@tonic-gate */ 15097c478bd9Sstevel@tonic-gate if ((oflags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) == FLG_OF_VERNEED) 15105aefb655Srie return (ld_vers_check_need(ofl)); 15117c478bd9Sstevel@tonic-gate else 15127c478bd9Sstevel@tonic-gate return (1); 15137c478bd9Sstevel@tonic-gate } 15147c478bd9Sstevel@tonic-gate 15157c478bd9Sstevel@tonic-gate /* 15167c478bd9Sstevel@tonic-gate * qsort(3c) comparison function. As an optimization for associating weak 15177c478bd9Sstevel@tonic-gate * symbols to their strong counterparts sort global symbols according to their 15187c478bd9Sstevel@tonic-gate * address and binding. 15197c478bd9Sstevel@tonic-gate */ 15207c478bd9Sstevel@tonic-gate static int 15217c478bd9Sstevel@tonic-gate compare(const void * sdpp1, const void * sdpp2) 15227c478bd9Sstevel@tonic-gate { 15237c478bd9Sstevel@tonic-gate Sym_desc * sdp1 = *((Sym_desc **)sdpp1); 15247c478bd9Sstevel@tonic-gate Sym_desc * sdp2 = *((Sym_desc **)sdpp2); 15257c478bd9Sstevel@tonic-gate Sym * sym1, * sym2; 15267c478bd9Sstevel@tonic-gate uchar_t bind1, bind2; 15277c478bd9Sstevel@tonic-gate 15287c478bd9Sstevel@tonic-gate /* 15297c478bd9Sstevel@tonic-gate * Symbol descriptors may be zero, move these to the front of the 15307c478bd9Sstevel@tonic-gate * sorted array. 15317c478bd9Sstevel@tonic-gate */ 15327c478bd9Sstevel@tonic-gate if (sdp1 == 0) 15337c478bd9Sstevel@tonic-gate return (-1); 15347c478bd9Sstevel@tonic-gate if (sdp2 == 0) 15357c478bd9Sstevel@tonic-gate return (1); 15367c478bd9Sstevel@tonic-gate 15377c478bd9Sstevel@tonic-gate sym1 = sdp1->sd_sym; 15387c478bd9Sstevel@tonic-gate sym2 = sdp2->sd_sym; 15397c478bd9Sstevel@tonic-gate 15407c478bd9Sstevel@tonic-gate /* 15417c478bd9Sstevel@tonic-gate * Compare the symbols value (address). 15427c478bd9Sstevel@tonic-gate */ 15437c478bd9Sstevel@tonic-gate if (sym1->st_value > sym2->st_value) 15447c478bd9Sstevel@tonic-gate return (1); 15457c478bd9Sstevel@tonic-gate if (sym1->st_value < sym2->st_value) 15467c478bd9Sstevel@tonic-gate return (-1); 15477c478bd9Sstevel@tonic-gate 15487c478bd9Sstevel@tonic-gate bind1 = ELF_ST_BIND(sym1->st_info); 15497c478bd9Sstevel@tonic-gate bind2 = ELF_ST_BIND(sym2->st_info); 15507c478bd9Sstevel@tonic-gate 15517c478bd9Sstevel@tonic-gate /* 15527c478bd9Sstevel@tonic-gate * If two symbols have the same address place the weak symbol before 15537c478bd9Sstevel@tonic-gate * any strong counterpart. 15547c478bd9Sstevel@tonic-gate */ 15557c478bd9Sstevel@tonic-gate if (bind1 > bind2) 15567c478bd9Sstevel@tonic-gate return (-1); 15577c478bd9Sstevel@tonic-gate if (bind1 < bind2) 15587c478bd9Sstevel@tonic-gate return (1); 15597c478bd9Sstevel@tonic-gate 15607c478bd9Sstevel@tonic-gate return (0); 15617c478bd9Sstevel@tonic-gate } 15627c478bd9Sstevel@tonic-gate 15637c478bd9Sstevel@tonic-gate 15647c478bd9Sstevel@tonic-gate /* 15657c478bd9Sstevel@tonic-gate * Process the symbol table for the specified input file. At this point all 15667c478bd9Sstevel@tonic-gate * input sections from this input file have been assigned an input section 15677c478bd9Sstevel@tonic-gate * descriptor which is saved in the `ifl_isdesc' array. 15687c478bd9Sstevel@tonic-gate * 15697c478bd9Sstevel@tonic-gate * o local symbols are saved (as is) if the input file is a 15707c478bd9Sstevel@tonic-gate * relocatable object 15717c478bd9Sstevel@tonic-gate * 15727c478bd9Sstevel@tonic-gate * o global symbols are added to the linkers internal symbol 15737c478bd9Sstevel@tonic-gate * table if they are not already present, otherwise a symbol 15747c478bd9Sstevel@tonic-gate * resolution function is called upon to resolve the conflict. 15757c478bd9Sstevel@tonic-gate */ 15767c478bd9Sstevel@tonic-gate uintptr_t 15775aefb655Srie ld_sym_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl) 15787c478bd9Sstevel@tonic-gate { 157975e45495Sab /* 158075e45495Sab * This macro tests the given symbol to see if it is out of 158175e45495Sab * range relative to the section it references. 158275e45495Sab * 158375e45495Sab * entry: 158475e45495Sab * - ifl is a relative object (ET_REL) 158575e45495Sab * _sdp - Symbol descriptor 158675e45495Sab * _sym - Symbol 158775e45495Sab * _type - Symbol type 158875e45495Sab * 158975e45495Sab * The following are tested: 159075e45495Sab * - Symbol length is non-zero 159175e45495Sab * - Symbol type is a type that references code or data 159275e45495Sab * - Referenced section is not 0 (indicates an UNDEF symbol) 159375e45495Sab * and is not in the range of special values above SHN_LORESERVE 159475e45495Sab * (excluding SHN_XINDEX, which is OK). 159575e45495Sab * - We have a valid section header for the target section 159675e45495Sab * 159775e45495Sab * If the above are all true, and the symbol position is not 159875e45495Sab * contained by the target section, this macro evaluates to 159975e45495Sab * True (1). Otherwise, False(0). 160075e45495Sab */ 160175e45495Sab #define SYM_LOC_BADADDR(_sdp, _sym, _type) \ 160275e45495Sab (_sym->st_size && dynaddr_symtype[_type] && \ 160375e45495Sab (_sym->st_shndx != SHN_UNDEF) && \ 160475e45495Sab ((_sym->st_shndx < SHN_LORESERVE) || \ 160575e45495Sab (_sym->st_shndx == SHN_XINDEX)) && \ 160675e45495Sab _sdp->sd_isc && _sdp->sd_isc->is_shdr && \ 160775e45495Sab ((_sym->st_value + _sym->st_size) > _sdp->sd_isc->is_shdr->sh_size)) 160875e45495Sab 16097c478bd9Sstevel@tonic-gate Sym *sym = (Sym *)isc->is_indata->d_buf; 16107c478bd9Sstevel@tonic-gate Word *symshndx = 0; 16117c478bd9Sstevel@tonic-gate Shdr *shdr = isc->is_shdr; 16127c478bd9Sstevel@tonic-gate Sym_desc *sdp; 16137c478bd9Sstevel@tonic-gate size_t strsize; 16147c478bd9Sstevel@tonic-gate char *strs; 16157c478bd9Sstevel@tonic-gate uchar_t type, bind; 16167c478bd9Sstevel@tonic-gate Word ndx, hash, local, total; 16177c478bd9Sstevel@tonic-gate Half etype = ifl->ifl_ehdr->e_type; 161875e45495Sab int etype_rel; 16197c478bd9Sstevel@tonic-gate const char *symsecname, *strsecname; 16207c478bd9Sstevel@tonic-gate avl_index_t where; 16217c478bd9Sstevel@tonic-gate 16227c478bd9Sstevel@tonic-gate /* 16237c478bd9Sstevel@tonic-gate * Its possible that a file may contain more that one symbol table, 16247c478bd9Sstevel@tonic-gate * ie. .dynsym and .symtab in a shared library. Only process the first 16257c478bd9Sstevel@tonic-gate * table (here, we assume .dynsym comes before .symtab). 16267c478bd9Sstevel@tonic-gate */ 16277c478bd9Sstevel@tonic-gate if (ifl->ifl_symscnt) 16287c478bd9Sstevel@tonic-gate return (1); 16297c478bd9Sstevel@tonic-gate 16307c478bd9Sstevel@tonic-gate if (isc->is_symshndx) 16317c478bd9Sstevel@tonic-gate symshndx = isc->is_symshndx->is_indata->d_buf; 16327c478bd9Sstevel@tonic-gate 16335aefb655Srie DBG_CALL(Dbg_syms_process(ofl->ofl_lml, ifl)); 16347c478bd9Sstevel@tonic-gate 16357c478bd9Sstevel@tonic-gate if (isc->is_name) 16367c478bd9Sstevel@tonic-gate symsecname = isc->is_name; 16377c478bd9Sstevel@tonic-gate else 16387c478bd9Sstevel@tonic-gate symsecname = MSG_ORIG(MSG_STR_EMPTY); 16397c478bd9Sstevel@tonic-gate 16407c478bd9Sstevel@tonic-gate /* 16417c478bd9Sstevel@tonic-gate * From the symbol tables section header information determine which 16427c478bd9Sstevel@tonic-gate * strtab table is needed to locate the actual symbol names. 16437c478bd9Sstevel@tonic-gate */ 16447c478bd9Sstevel@tonic-gate if (ifl->ifl_flags & FLG_IF_HSTRTAB) { 16457c478bd9Sstevel@tonic-gate ndx = shdr->sh_link; 16467c478bd9Sstevel@tonic-gate if ((ndx == 0) || (ndx >= ifl->ifl_shnum)) { 16475aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 16485aefb655Srie MSG_INTL(MSG_FIL_INVSHLINK), 16497c478bd9Sstevel@tonic-gate ifl->ifl_name, symsecname, EC_XWORD(ndx)); 16507c478bd9Sstevel@tonic-gate return (S_ERROR); 16517c478bd9Sstevel@tonic-gate } 16527c478bd9Sstevel@tonic-gate strsize = ifl->ifl_isdesc[ndx]->is_shdr->sh_size; 16537c478bd9Sstevel@tonic-gate strs = ifl->ifl_isdesc[ndx]->is_indata->d_buf; 16547c478bd9Sstevel@tonic-gate if (ifl->ifl_isdesc[ndx]->is_name) 16557c478bd9Sstevel@tonic-gate strsecname = ifl->ifl_isdesc[ndx]->is_name; 16567c478bd9Sstevel@tonic-gate else 16577c478bd9Sstevel@tonic-gate strsecname = MSG_ORIG(MSG_STR_EMPTY); 16587c478bd9Sstevel@tonic-gate } else { 16597c478bd9Sstevel@tonic-gate /* 16607c478bd9Sstevel@tonic-gate * There is no string table section in this input file 16617c478bd9Sstevel@tonic-gate * although there are symbols in this symbol table section. 16627c478bd9Sstevel@tonic-gate * This means that these symbols do not have names. 16637c478bd9Sstevel@tonic-gate * Currently, only scratch register symbols are allowed 16647c478bd9Sstevel@tonic-gate * not to have names. 16657c478bd9Sstevel@tonic-gate */ 16667c478bd9Sstevel@tonic-gate strsize = 0; 16677c478bd9Sstevel@tonic-gate strs = (char *)MSG_ORIG(MSG_STR_EMPTY); 16687c478bd9Sstevel@tonic-gate strsecname = MSG_ORIG(MSG_STR_EMPTY); 16697c478bd9Sstevel@tonic-gate } 16707c478bd9Sstevel@tonic-gate 16717c478bd9Sstevel@tonic-gate /* 16727c478bd9Sstevel@tonic-gate * Determine the number of local symbols together with the total 16737c478bd9Sstevel@tonic-gate * number we have to process. 16747c478bd9Sstevel@tonic-gate */ 16757c478bd9Sstevel@tonic-gate total = (Word)(shdr->sh_size / shdr->sh_entsize); 16767c478bd9Sstevel@tonic-gate local = shdr->sh_info; 16777c478bd9Sstevel@tonic-gate 16787c478bd9Sstevel@tonic-gate /* 16797c478bd9Sstevel@tonic-gate * Allocate a symbol table index array and a local symbol array 16807c478bd9Sstevel@tonic-gate * (global symbols are processed and added to the ofl->ofl_symbkt[] 16817c478bd9Sstevel@tonic-gate * array). If we are dealing with a relocatable object, allocate the 16827c478bd9Sstevel@tonic-gate * local symbol descriptors. If this isn't a relocatable object we 16837c478bd9Sstevel@tonic-gate * still have to process any shared object locals to determine if any 16847c478bd9Sstevel@tonic-gate * register symbols exist. Although these aren't added to the output 16857c478bd9Sstevel@tonic-gate * image, they are used as part of symbol resolution. 16867c478bd9Sstevel@tonic-gate */ 16877c478bd9Sstevel@tonic-gate if ((ifl->ifl_oldndx = libld_malloc((size_t)(total * 16887c478bd9Sstevel@tonic-gate sizeof (Sym_desc *)))) == 0) 16897c478bd9Sstevel@tonic-gate return (S_ERROR); 169075e45495Sab etype_rel = etype == ET_REL; 169175e45495Sab if (etype_rel && local) { 16927c478bd9Sstevel@tonic-gate if ((ifl->ifl_locs = 16937c478bd9Sstevel@tonic-gate libld_calloc(sizeof (Sym_desc), local)) == 0) 16947c478bd9Sstevel@tonic-gate return (S_ERROR); 16957c478bd9Sstevel@tonic-gate /* LINTED */ 16967c478bd9Sstevel@tonic-gate ifl->ifl_locscnt = (Word)local; 16977c478bd9Sstevel@tonic-gate } 16987c478bd9Sstevel@tonic-gate ifl->ifl_symscnt = total; 16997c478bd9Sstevel@tonic-gate 17007c478bd9Sstevel@tonic-gate /* 17017c478bd9Sstevel@tonic-gate * If there are local symbols to save add them to the symbol table 17027c478bd9Sstevel@tonic-gate * index array. 17037c478bd9Sstevel@tonic-gate */ 17047c478bd9Sstevel@tonic-gate if (local) { 17059039eeafSab int allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl); 17067c478bd9Sstevel@tonic-gate for (sym++, ndx = 1; ndx < local; sym++, ndx++) { 17077c478bd9Sstevel@tonic-gate Word shndx, sdflags = FLG_SY_CLEAN; 17087c478bd9Sstevel@tonic-gate const char *name; 17097c478bd9Sstevel@tonic-gate Sym_desc *rsdp; 17107c478bd9Sstevel@tonic-gate 17117c478bd9Sstevel@tonic-gate /* 17127c478bd9Sstevel@tonic-gate * Determine the associated section index. 17137c478bd9Sstevel@tonic-gate */ 17147c478bd9Sstevel@tonic-gate if (symshndx && (sym->st_shndx == SHN_XINDEX)) 17157c478bd9Sstevel@tonic-gate shndx = symshndx[ndx]; 17167c478bd9Sstevel@tonic-gate else if ((shndx = sym->st_shndx) >= SHN_LORESERVE) 17177c478bd9Sstevel@tonic-gate sdflags |= FLG_SY_SPECSEC; 17187c478bd9Sstevel@tonic-gate 17197c478bd9Sstevel@tonic-gate /* 17207c478bd9Sstevel@tonic-gate * Check if st_name has a valid value or not. 17217c478bd9Sstevel@tonic-gate */ 17225aefb655Srie if ((name = string(ofl, ifl, sym, strs, strsize, ndx, 17237c478bd9Sstevel@tonic-gate shndx, symsecname, strsecname, &sdflags)) == 0) { 17247c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 17257c478bd9Sstevel@tonic-gate continue; 17267c478bd9Sstevel@tonic-gate } 17277c478bd9Sstevel@tonic-gate 17287c478bd9Sstevel@tonic-gate /* 17297c478bd9Sstevel@tonic-gate * If this local symbol table originates from a shared 17307c478bd9Sstevel@tonic-gate * object, then we're only interested in recording 17317c478bd9Sstevel@tonic-gate * register symbols. As local symbol descriptors aren't 17327c478bd9Sstevel@tonic-gate * allocated for shared objects, one will be allocated 17337c478bd9Sstevel@tonic-gate * to associated with the register symbol. This symbol 17347c478bd9Sstevel@tonic-gate * won't become part of the output image, but we must 17357c478bd9Sstevel@tonic-gate * process it to test for register conflicts. 17367c478bd9Sstevel@tonic-gate */ 17377c478bd9Sstevel@tonic-gate rsdp = sdp = 0; 17387c478bd9Sstevel@tonic-gate if (sdflags & FLG_SY_REGSYM) { 17395aefb655Srie if ((rsdp = ld_reg_find(sym, ofl)) != 0) { 17407c478bd9Sstevel@tonic-gate /* 17417c478bd9Sstevel@tonic-gate * The fact that another register def- 17427c478bd9Sstevel@tonic-gate * inition has been found is fatal. 17437c478bd9Sstevel@tonic-gate * Call the verification routine to get 17447c478bd9Sstevel@tonic-gate * the error message and move on. 17457c478bd9Sstevel@tonic-gate */ 17465aefb655Srie (void) ld_reg_check(rsdp, sym, name, 17477c478bd9Sstevel@tonic-gate ifl, ofl); 17487c478bd9Sstevel@tonic-gate continue; 17497c478bd9Sstevel@tonic-gate } 17507c478bd9Sstevel@tonic-gate 17517c478bd9Sstevel@tonic-gate if (etype == ET_DYN) { 17527c478bd9Sstevel@tonic-gate if ((sdp = libld_calloc( 17537c478bd9Sstevel@tonic-gate sizeof (Sym_desc), 1)) == 0) 17547c478bd9Sstevel@tonic-gate return (S_ERROR); 17557c478bd9Sstevel@tonic-gate sdp->sd_ref = REF_DYN_SEEN; 17567c478bd9Sstevel@tonic-gate } 17577c478bd9Sstevel@tonic-gate } else if (etype == ET_DYN) 17587c478bd9Sstevel@tonic-gate continue; 17597c478bd9Sstevel@tonic-gate 17607c478bd9Sstevel@tonic-gate /* 17617c478bd9Sstevel@tonic-gate * Fill in the remaining symbol descriptor information. 17627c478bd9Sstevel@tonic-gate */ 17637c478bd9Sstevel@tonic-gate if (sdp == 0) { 17647c478bd9Sstevel@tonic-gate sdp = &(ifl->ifl_locs[ndx]); 17657c478bd9Sstevel@tonic-gate sdp->sd_ref = REF_REL_NEED; 17667c478bd9Sstevel@tonic-gate } 17677c478bd9Sstevel@tonic-gate if (rsdp == 0) { 17687c478bd9Sstevel@tonic-gate sdp->sd_name = name; 17697c478bd9Sstevel@tonic-gate sdp->sd_sym = sym; 17707c478bd9Sstevel@tonic-gate sdp->sd_shndx = shndx; 17717c478bd9Sstevel@tonic-gate sdp->sd_flags = sdflags; 17727c478bd9Sstevel@tonic-gate sdp->sd_file = ifl; 17737c478bd9Sstevel@tonic-gate ifl->ifl_oldndx[ndx] = sdp; 17747c478bd9Sstevel@tonic-gate } 17757c478bd9Sstevel@tonic-gate 17765aefb655Srie DBG_CALL(Dbg_syms_entry(ofl->ofl_lml, ndx, sdp)); 17777c478bd9Sstevel@tonic-gate 17787c478bd9Sstevel@tonic-gate /* 17797c478bd9Sstevel@tonic-gate * Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF 17807c478bd9Sstevel@tonic-gate * so as to simplify future processing. 17817c478bd9Sstevel@tonic-gate */ 17820bc07c75Srie if (sym->st_shndx == SHN_SUNW_IGNORE) { 17837c478bd9Sstevel@tonic-gate sdp->sd_shndx = shndx = SHN_UNDEF; 17847c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= 17857c478bd9Sstevel@tonic-gate (FLG_SY1_IGNORE | FLG_SY1_ELIM); 17867c478bd9Sstevel@tonic-gate } 17877c478bd9Sstevel@tonic-gate 17887c478bd9Sstevel@tonic-gate /* 17897c478bd9Sstevel@tonic-gate * Process any register symbols. 17907c478bd9Sstevel@tonic-gate */ 17917c478bd9Sstevel@tonic-gate if (sdp->sd_flags & FLG_SY_REGSYM) { 17927c478bd9Sstevel@tonic-gate /* 17937c478bd9Sstevel@tonic-gate * Add a diagnostic to indicate we've caught a 17947c478bd9Sstevel@tonic-gate * register symbol, as this can be useful if a 17957c478bd9Sstevel@tonic-gate * register conflict is later discovered. 17967c478bd9Sstevel@tonic-gate */ 17975aefb655Srie DBG_CALL(Dbg_syms_entered(ofl, sym, sdp)); 17987c478bd9Sstevel@tonic-gate 17997c478bd9Sstevel@tonic-gate /* 18007c478bd9Sstevel@tonic-gate * If this register symbol hasn't already been 18017c478bd9Sstevel@tonic-gate * recorded, enter it now. 18027c478bd9Sstevel@tonic-gate */ 18035aefb655Srie if ((rsdp == 0) && 18045aefb655Srie (ld_reg_enter(sdp, ofl) == 0)) 18057c478bd9Sstevel@tonic-gate return (S_ERROR); 18067c478bd9Sstevel@tonic-gate } 18077c478bd9Sstevel@tonic-gate 18087c478bd9Sstevel@tonic-gate /* 18097c478bd9Sstevel@tonic-gate * Assign an input section. 18107c478bd9Sstevel@tonic-gate */ 18110bc07c75Srie if ((sym->st_shndx != SHN_UNDEF) && 18127c478bd9Sstevel@tonic-gate ((sdp->sd_flags & FLG_SY_SPECSEC) == 0)) 18137c478bd9Sstevel@tonic-gate sdp->sd_isc = ifl->ifl_isdesc[shndx]; 18147c478bd9Sstevel@tonic-gate 18157c478bd9Sstevel@tonic-gate /* 18167c478bd9Sstevel@tonic-gate * If this symbol falls within the range of a section 18177c478bd9Sstevel@tonic-gate * being discarded, then discard the symbol itself. 18187c478bd9Sstevel@tonic-gate * There is no reason to keep this local symbol. 18197c478bd9Sstevel@tonic-gate */ 18207c478bd9Sstevel@tonic-gate if (sdp->sd_isc && 18217c478bd9Sstevel@tonic-gate (sdp->sd_isc->is_flags & FLG_IS_DISCARD)) { 18227c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_ISDISC; 18235aefb655Srie DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, 18245aefb655Srie sdp, sdp->sd_isc)); 18257c478bd9Sstevel@tonic-gate continue; 18267c478bd9Sstevel@tonic-gate } 18277c478bd9Sstevel@tonic-gate 18287c478bd9Sstevel@tonic-gate /* 18297c478bd9Sstevel@tonic-gate * Skip any section symbols as new versions of these 18307c478bd9Sstevel@tonic-gate * will be created. 18317c478bd9Sstevel@tonic-gate */ 18327c478bd9Sstevel@tonic-gate if ((type = ELF_ST_TYPE(sym->st_info)) == STT_SECTION) { 18330bc07c75Srie if (sym->st_shndx == SHN_UNDEF) { 18345aefb655Srie eprintf(ofl->ofl_lml, ERR_WARNING, 18357c478bd9Sstevel@tonic-gate MSG_INTL(MSG_SYM_INVSHNDX), 18367c478bd9Sstevel@tonic-gate demangle(sdp->sd_name), 18377c478bd9Sstevel@tonic-gate ifl->ifl_name, 18380bc07c75Srie conv_sym_shndx(sym->st_shndx)); 18397c478bd9Sstevel@tonic-gate } 18407c478bd9Sstevel@tonic-gate continue; 18417c478bd9Sstevel@tonic-gate } 18427c478bd9Sstevel@tonic-gate 184375e45495Sab /* 184475e45495Sab * For a relocatable object, if this symbol is defined 184575e45495Sab * and has non-zero length and references an address 184675e45495Sab * within an associated section, then check its extents 184775e45495Sab * to make sure the section boundaries encompass it. 184875e45495Sab * If they don't, the ELF file is corrupt. 184975e45495Sab */ 185075e45495Sab if (etype_rel && SYM_LOC_BADADDR(sdp, sym, type)) { 185175e45495Sab eprintf(ofl->ofl_lml, ERR_FATAL, 185275e45495Sab MSG_INTL(MSG_SYM_BADADDR), 185375e45495Sab demangle(sdp->sd_name), ifl->ifl_name, 185475e45495Sab shndx, sdp->sd_isc->is_name, 185575e45495Sab EC_XWORD(sdp->sd_isc->is_shdr->sh_size), 185675e45495Sab EC_XWORD(sym->st_value), 185775e45495Sab EC_XWORD(sym->st_size)); 185875e45495Sab ofl->ofl_flags |= FLG_OF_FATAL; 185975e45495Sab continue; 186075e45495Sab } 186175e45495Sab 18627c478bd9Sstevel@tonic-gate /* 18637c478bd9Sstevel@tonic-gate * Sanity check for TLS 18647c478bd9Sstevel@tonic-gate */ 18650bc07c75Srie if ((sym->st_size != 0) && ((type == STT_TLS) && 18660bc07c75Srie (sym->st_shndx != SHN_COMMON))) { 18677c478bd9Sstevel@tonic-gate Is_desc *isp = sdp->sd_isc; 18687c478bd9Sstevel@tonic-gate 18697c478bd9Sstevel@tonic-gate if ((isp == 0) || (isp->is_shdr == 0) || 18707c478bd9Sstevel@tonic-gate ((isp->is_shdr->sh_flags & SHF_TLS) == 0)) { 18715aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 18727c478bd9Sstevel@tonic-gate MSG_INTL(MSG_SYM_TLS), 18737c478bd9Sstevel@tonic-gate demangle(sdp->sd_name), 18747c478bd9Sstevel@tonic-gate ifl->ifl_name); 18757c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 18767c478bd9Sstevel@tonic-gate continue; 18777c478bd9Sstevel@tonic-gate } 18787c478bd9Sstevel@tonic-gate } 18797c478bd9Sstevel@tonic-gate 18807c478bd9Sstevel@tonic-gate /* 18817c478bd9Sstevel@tonic-gate * Carry our some basic sanity checks (these are just 18827c478bd9Sstevel@tonic-gate * some of the erroneous symbol entries we've come 18837c478bd9Sstevel@tonic-gate * across, there's probably a lot more). The symbol 18847c478bd9Sstevel@tonic-gate * will not be carried forward to the output file, which 18857c478bd9Sstevel@tonic-gate * won't be a problem unless a relocation is required 18867c478bd9Sstevel@tonic-gate * against it. 18877c478bd9Sstevel@tonic-gate */ 18887c478bd9Sstevel@tonic-gate if (((sdp->sd_flags & FLG_SY_SPECSEC) && 18890bc07c75Srie ((sym->st_shndx == SHN_COMMON)) || 18900bc07c75Srie ((type == STT_FILE) && 18910bc07c75Srie (sym->st_shndx != SHN_ABS))) || 18927c478bd9Sstevel@tonic-gate (sdp->sd_isc && (sdp->sd_isc->is_osdesc == 0))) { 18935aefb655Srie eprintf(ofl->ofl_lml, ERR_WARNING, 18945aefb655Srie MSG_INTL(MSG_SYM_INVSHNDX), 18957c478bd9Sstevel@tonic-gate demangle(sdp->sd_name), ifl->ifl_name, 18960bc07c75Srie conv_sym_shndx(sym->st_shndx)); 18977c478bd9Sstevel@tonic-gate sdp->sd_isc = NULL; 18987c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_INVALID; 18997c478bd9Sstevel@tonic-gate continue; 19007c478bd9Sstevel@tonic-gate } 19017c478bd9Sstevel@tonic-gate 19027c478bd9Sstevel@tonic-gate /* 19037c478bd9Sstevel@tonic-gate * As these local symbols will become part of the output 19047c478bd9Sstevel@tonic-gate * image, record their number and name string size. 19057c478bd9Sstevel@tonic-gate * Globals are counted after all input file processing 19067c478bd9Sstevel@tonic-gate * (and hence symbol resolution) is complete during 19077c478bd9Sstevel@tonic-gate * sym_validate(). 19087c478bd9Sstevel@tonic-gate */ 19097c478bd9Sstevel@tonic-gate if (!(ofl->ofl_flags1 & FLG_OF1_REDLSYM)) { 19107c478bd9Sstevel@tonic-gate ofl->ofl_locscnt++; 19117c478bd9Sstevel@tonic-gate 19127c478bd9Sstevel@tonic-gate if ((((sdp->sd_flags & FLG_SY_REGSYM) == 0) || 19137c478bd9Sstevel@tonic-gate sym->st_name) && (st_insert(ofl->ofl_strtab, 19147c478bd9Sstevel@tonic-gate sdp->sd_name) == -1)) 19157c478bd9Sstevel@tonic-gate return (S_ERROR); 19169039eeafSab 19179039eeafSab if (allow_ldynsym && sym->st_name && 19189039eeafSab ((type == STT_FUNC) || 19199039eeafSab (type == STT_FILE))) { 19209039eeafSab ofl->ofl_dynlocscnt++; 19219039eeafSab if (st_insert(ofl->ofl_dynstrtab, 19229039eeafSab sdp->sd_name) == -1) 19239039eeafSab return (S_ERROR); 19249039eeafSab } 19257c478bd9Sstevel@tonic-gate } 19267c478bd9Sstevel@tonic-gate } 19277c478bd9Sstevel@tonic-gate } 19287c478bd9Sstevel@tonic-gate 19297c478bd9Sstevel@tonic-gate /* 19307c478bd9Sstevel@tonic-gate * Now scan the global symbols entering them in the internal symbol 19317c478bd9Sstevel@tonic-gate * table or resolving them as necessary. 19327c478bd9Sstevel@tonic-gate */ 19337c478bd9Sstevel@tonic-gate sym = (Sym *)isc->is_indata->d_buf; 19347c478bd9Sstevel@tonic-gate sym += local; 19357c478bd9Sstevel@tonic-gate /* LINTED */ 19367c478bd9Sstevel@tonic-gate for (ndx = (int)local; ndx < total; sym++, ndx++) { 19377c478bd9Sstevel@tonic-gate const char *name; 19387c478bd9Sstevel@tonic-gate Word shndx, sdflags = 0; 19397c478bd9Sstevel@tonic-gate 19407c478bd9Sstevel@tonic-gate /* 19417c478bd9Sstevel@tonic-gate * Determine the associated section index. 19427c478bd9Sstevel@tonic-gate */ 19437c478bd9Sstevel@tonic-gate if (symshndx && (sym->st_shndx == SHN_XINDEX)) { 19447c478bd9Sstevel@tonic-gate shndx = symshndx[ndx]; 19457c478bd9Sstevel@tonic-gate } else { 19467c478bd9Sstevel@tonic-gate shndx = sym->st_shndx; 19477c478bd9Sstevel@tonic-gate if (sym->st_shndx >= SHN_LORESERVE) 19487c478bd9Sstevel@tonic-gate sdflags |= FLG_SY_SPECSEC; 19497c478bd9Sstevel@tonic-gate } 19507c478bd9Sstevel@tonic-gate 19517c478bd9Sstevel@tonic-gate /* 19527c478bd9Sstevel@tonic-gate * Check if st_name has a valid value or not. 19537c478bd9Sstevel@tonic-gate */ 19545aefb655Srie if ((name = string(ofl, ifl, sym, strs, strsize, ndx, shndx, 19557c478bd9Sstevel@tonic-gate symsecname, strsecname, &sdflags)) == 0) { 19567c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 19577c478bd9Sstevel@tonic-gate continue; 19587c478bd9Sstevel@tonic-gate } 19597c478bd9Sstevel@tonic-gate 19607c478bd9Sstevel@tonic-gate /* 19617c478bd9Sstevel@tonic-gate * The linker itself will generate symbols for _end, _etext, 19627c478bd9Sstevel@tonic-gate * _edata, _DYNAMIC and _PROCEDURE_LINKAGE_TABLE_, so don't 19637c478bd9Sstevel@tonic-gate * bother entering these symbols from shared objects. This 19647c478bd9Sstevel@tonic-gate * results in some wasted resolution processing, which is hard 19657c478bd9Sstevel@tonic-gate * to feel, but if nothing else, pollutes diagnostic relocation 19667c478bd9Sstevel@tonic-gate * output. 19677c478bd9Sstevel@tonic-gate */ 19687c478bd9Sstevel@tonic-gate if (name[0] && (etype == ET_DYN) && (sym->st_size == 0) && 19697c478bd9Sstevel@tonic-gate (ELF_ST_TYPE(sym->st_info) == STT_OBJECT) && 19707c478bd9Sstevel@tonic-gate (name[0] == '_') && ((name[1] == 'e') || 19717c478bd9Sstevel@tonic-gate (name[1] == 'D') || (name[1] == 'P')) && 19727c478bd9Sstevel@tonic-gate ((strcmp(name, MSG_ORIG(MSG_SYM_ETEXT_U)) == 0) || 19737c478bd9Sstevel@tonic-gate (strcmp(name, MSG_ORIG(MSG_SYM_EDATA_U)) == 0) || 19747c478bd9Sstevel@tonic-gate (strcmp(name, MSG_ORIG(MSG_SYM_END_U)) == 0) || 19757c478bd9Sstevel@tonic-gate (strcmp(name, MSG_ORIG(MSG_SYM_DYNAMIC_U)) == 0) || 19767c478bd9Sstevel@tonic-gate (strcmp(name, MSG_ORIG(MSG_SYM_PLKTBL_U)) == 0))) { 19777c478bd9Sstevel@tonic-gate ifl->ifl_oldndx[ndx] = 0; 19787c478bd9Sstevel@tonic-gate continue; 19797c478bd9Sstevel@tonic-gate } 19807c478bd9Sstevel@tonic-gate 19817c478bd9Sstevel@tonic-gate /* 19827c478bd9Sstevel@tonic-gate * Determine and validate the symbols binding. 19837c478bd9Sstevel@tonic-gate */ 19847c478bd9Sstevel@tonic-gate bind = ELF_ST_BIND(sym->st_info); 19857c478bd9Sstevel@tonic-gate if ((bind != STB_GLOBAL) && (bind != STB_WEAK)) { 19865aefb655Srie eprintf(ofl->ofl_lml, ERR_WARNING, 19875aefb655Srie MSG_INTL(MSG_SYM_NONGLOB), demangle(name), 1988c13de8f6Sab ifl->ifl_name, conv_sym_info_bind(bind, 0)); 19897c478bd9Sstevel@tonic-gate continue; 19907c478bd9Sstevel@tonic-gate } 19917c478bd9Sstevel@tonic-gate 19927c478bd9Sstevel@tonic-gate /* 19937c478bd9Sstevel@tonic-gate * If this symbol falls within the range of a section being 19947c478bd9Sstevel@tonic-gate * discarded, then discard the symbol itself. 19957c478bd9Sstevel@tonic-gate */ 19967c478bd9Sstevel@tonic-gate if (((sdflags & FLG_SY_SPECSEC) == 0) && 19970bc07c75Srie (sym->st_shndx != SHN_UNDEF)) { 19987c478bd9Sstevel@tonic-gate Is_desc *isp; 19997c478bd9Sstevel@tonic-gate 20007c478bd9Sstevel@tonic-gate if (shndx >= ifl->ifl_shnum) { 20017c478bd9Sstevel@tonic-gate /* 20027c478bd9Sstevel@tonic-gate * Carry our some basic sanity checks 20037c478bd9Sstevel@tonic-gate * The symbol will not be carried forward to 20047c478bd9Sstevel@tonic-gate * the output file, which won't be a problem 20057c478bd9Sstevel@tonic-gate * unless a relocation is required against it. 20067c478bd9Sstevel@tonic-gate */ 20075aefb655Srie eprintf(ofl->ofl_lml, ERR_WARNING, 20085aefb655Srie MSG_INTL(MSG_SYM_INVSHNDX), demangle(name), 20090bc07c75Srie ifl->ifl_name, 20100bc07c75Srie conv_sym_shndx(sym->st_shndx)); 20117c478bd9Sstevel@tonic-gate continue; 20127c478bd9Sstevel@tonic-gate } 20137c478bd9Sstevel@tonic-gate 20147c478bd9Sstevel@tonic-gate isp = ifl->ifl_isdesc[shndx]; 20157c478bd9Sstevel@tonic-gate if (isp && (isp->is_flags & FLG_IS_DISCARD)) { 20167c478bd9Sstevel@tonic-gate if ((sdp = 20177c478bd9Sstevel@tonic-gate libld_calloc(sizeof (Sym_desc), 1)) == 0) 20187c478bd9Sstevel@tonic-gate return (S_ERROR); 20197c478bd9Sstevel@tonic-gate 20207c478bd9Sstevel@tonic-gate /* 20217c478bd9Sstevel@tonic-gate * Create a dummy symbol entry so that if we 20227c478bd9Sstevel@tonic-gate * find any references to this discarded symbol 20237c478bd9Sstevel@tonic-gate * we can compensate. 20247c478bd9Sstevel@tonic-gate */ 20257c478bd9Sstevel@tonic-gate sdp->sd_name = name; 20267c478bd9Sstevel@tonic-gate sdp->sd_sym = sym; 20277c478bd9Sstevel@tonic-gate sdp->sd_file = ifl; 20287c478bd9Sstevel@tonic-gate sdp->sd_isc = isp; 20297c478bd9Sstevel@tonic-gate sdp->sd_flags = FLG_SY_ISDISC; 20307c478bd9Sstevel@tonic-gate ifl->ifl_oldndx[ndx] = sdp; 20317c478bd9Sstevel@tonic-gate 20325aefb655Srie DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp, 20335aefb655Srie sdp->sd_isc)); 20347c478bd9Sstevel@tonic-gate continue; 20357c478bd9Sstevel@tonic-gate } 20367c478bd9Sstevel@tonic-gate } 20377c478bd9Sstevel@tonic-gate 20387c478bd9Sstevel@tonic-gate /* 20397c478bd9Sstevel@tonic-gate * If the symbol does not already exist in the internal symbol 20407c478bd9Sstevel@tonic-gate * table add it, otherwise resolve the conflict. If the symbol 20417c478bd9Sstevel@tonic-gate * from this file is kept, retain its symbol table index for 20427c478bd9Sstevel@tonic-gate * possible use in associating a global alias. 20437c478bd9Sstevel@tonic-gate */ 20447c478bd9Sstevel@tonic-gate /* LINTED */ 20457c478bd9Sstevel@tonic-gate hash = (Word)elf_hash((const char *)name); 20465aefb655Srie if ((sdp = ld_sym_find(name, hash, &where, ofl)) == NULL) { 20475aefb655Srie DBG_CALL(Dbg_syms_global(ofl->ofl_lml, ndx, name)); 20485aefb655Srie if ((sdp = ld_sym_enter(name, sym, hash, ifl, ofl, ndx, 20497c478bd9Sstevel@tonic-gate shndx, sdflags, 0, &where)) == (Sym_desc *)S_ERROR) 20507c478bd9Sstevel@tonic-gate return (S_ERROR); 20517c478bd9Sstevel@tonic-gate 20525aefb655Srie } else if (ld_sym_resolve(sdp, sym, ifl, ofl, ndx, shndx, 20537c478bd9Sstevel@tonic-gate sdflags) == S_ERROR) 20547c478bd9Sstevel@tonic-gate return (S_ERROR); 20557c478bd9Sstevel@tonic-gate 20567c478bd9Sstevel@tonic-gate /* 20577c478bd9Sstevel@tonic-gate * After we've compared a defined symbol in one shared 20587c478bd9Sstevel@tonic-gate * object, flag the symbol so we don't compare it again. 20597c478bd9Sstevel@tonic-gate */ 20600bc07c75Srie if ((etype == ET_DYN) && (sym->st_shndx != SHN_UNDEF) && 20617c478bd9Sstevel@tonic-gate ((sdp->sd_flags & FLG_SY_SOFOUND) == 0)) 20627c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_SOFOUND; 20637c478bd9Sstevel@tonic-gate 20647c478bd9Sstevel@tonic-gate /* 20657c478bd9Sstevel@tonic-gate * If the symbol is accepted from this file retain the symbol 20667c478bd9Sstevel@tonic-gate * index for possible use in aliasing. 20677c478bd9Sstevel@tonic-gate */ 20687c478bd9Sstevel@tonic-gate if (sdp->sd_file == ifl) 20697c478bd9Sstevel@tonic-gate sdp->sd_symndx = ndx; 20707c478bd9Sstevel@tonic-gate 20717c478bd9Sstevel@tonic-gate ifl->ifl_oldndx[ndx] = sdp; 20727c478bd9Sstevel@tonic-gate 20737c478bd9Sstevel@tonic-gate /* 20747c478bd9Sstevel@tonic-gate * If we've accepted a register symbol, continue to validate 20757c478bd9Sstevel@tonic-gate * it. 20767c478bd9Sstevel@tonic-gate */ 20777c478bd9Sstevel@tonic-gate if (sdp->sd_flags & FLG_SY_REGSYM) { 20787c478bd9Sstevel@tonic-gate Sym_desc *rsdp; 20797c478bd9Sstevel@tonic-gate 20805aefb655Srie if ((rsdp = ld_reg_find(sdp->sd_sym, ofl)) == 0) { 20815aefb655Srie if (ld_reg_enter(sdp, ofl) == 0) 20827c478bd9Sstevel@tonic-gate return (S_ERROR); 20837c478bd9Sstevel@tonic-gate } else if (rsdp != sdp) { 20845aefb655Srie (void) ld_reg_check(rsdp, sdp->sd_sym, 20857c478bd9Sstevel@tonic-gate sdp->sd_name, ifl, ofl); 20867c478bd9Sstevel@tonic-gate } 20877c478bd9Sstevel@tonic-gate } 208875e45495Sab 208975e45495Sab /* 209075e45495Sab * For a relocatable object, if this symbol is defined 209175e45495Sab * and has non-zero length and references an address 209275e45495Sab * within an associated section, then check its extents 209375e45495Sab * to make sure the section boundaries encompass it. 209475e45495Sab * If they don't, the ELF file is corrupt. Note that this 209575e45495Sab * global symbol may have come from another file to satisfy 209675e45495Sab * an UNDEF symbol of the same name from this one. In that 209775e45495Sab * case, we don't check it, because it was already checked 209875e45495Sab * as part of its own file. 209975e45495Sab */ 210075e45495Sab if (etype_rel && (sdp->sd_file == ifl)) { 210175e45495Sab Sym *tsym = sdp->sd_sym; 210275e45495Sab 210375e45495Sab if (SYM_LOC_BADADDR(sdp, tsym, 210475e45495Sab ELF_ST_TYPE(tsym->st_info))) { 210575e45495Sab eprintf(ofl->ofl_lml, ERR_FATAL, 210675e45495Sab MSG_INTL(MSG_SYM_BADADDR), 210775e45495Sab demangle(sdp->sd_name), ifl->ifl_name, 210875e45495Sab tsym->st_shndx, sdp->sd_isc->is_name, 210975e45495Sab EC_XWORD(sdp->sd_isc->is_shdr->sh_size), 211075e45495Sab EC_XWORD(tsym->st_value), 211175e45495Sab EC_XWORD(tsym->st_size)); 211275e45495Sab ofl->ofl_flags |= FLG_OF_FATAL; 211375e45495Sab continue; 211475e45495Sab } 211575e45495Sab } 21167c478bd9Sstevel@tonic-gate } 21177c478bd9Sstevel@tonic-gate 21187c478bd9Sstevel@tonic-gate /* 21197c478bd9Sstevel@tonic-gate * If this is a shared object scan the globals one more time and 21207c478bd9Sstevel@tonic-gate * associate any weak/global associations. This association is needed 21217c478bd9Sstevel@tonic-gate * should the weak definition satisfy a reference in the dynamic 21227c478bd9Sstevel@tonic-gate * executable: 21237c478bd9Sstevel@tonic-gate * 21247c478bd9Sstevel@tonic-gate * o if the symbol is a data item it will be copied to the 21257c478bd9Sstevel@tonic-gate * executables address space, thus we must also reassociate the 21267c478bd9Sstevel@tonic-gate * alias symbol with its new location in the executable. 21277c478bd9Sstevel@tonic-gate * 21287c478bd9Sstevel@tonic-gate * o if the symbol is a function then we may need to promote the 21297c478bd9Sstevel@tonic-gate * symbols binding from undefined weak to undefined, otherwise the 21307c478bd9Sstevel@tonic-gate * run-time linker will not generate the correct relocation error 21317c478bd9Sstevel@tonic-gate * should the symbol not be found. 21327c478bd9Sstevel@tonic-gate * 21337c478bd9Sstevel@tonic-gate * The true association between a weak/strong symbol pair is that both 21347c478bd9Sstevel@tonic-gate * symbol entries are identical, thus first we created a sorted symbol 21357c478bd9Sstevel@tonic-gate * list keyed off of the symbols value (if the value is the same chances 21367c478bd9Sstevel@tonic-gate * are the rest of the symbols data is). This list is then scanned for 21377c478bd9Sstevel@tonic-gate * weak symbols, and if one is found then any strong association will 21387c478bd9Sstevel@tonic-gate * exist in the following entries. Thus we just have to scan one 21397c478bd9Sstevel@tonic-gate * (typical single alias) or more (in the uncommon instance of multiple 21407c478bd9Sstevel@tonic-gate * weak to strong associations) entries to determine if a match exists. 21417c478bd9Sstevel@tonic-gate */ 21427c478bd9Sstevel@tonic-gate if (ifl->ifl_ehdr->e_type == ET_DYN) { 21437c478bd9Sstevel@tonic-gate Sym_desc ** sort; 21447c478bd9Sstevel@tonic-gate size_t size = (total - local) * sizeof (Sym_desc *); 21457c478bd9Sstevel@tonic-gate 21467c478bd9Sstevel@tonic-gate if ((sort = libld_malloc(size)) == 0) 21477c478bd9Sstevel@tonic-gate return (S_ERROR); 21487c478bd9Sstevel@tonic-gate (void) memcpy((void *)sort, &ifl->ifl_oldndx[local], size); 21497c478bd9Sstevel@tonic-gate 21507c478bd9Sstevel@tonic-gate qsort(sort, (total - local), sizeof (Sym_desc *), compare); 21517c478bd9Sstevel@tonic-gate 21527c478bd9Sstevel@tonic-gate for (ndx = 0; ndx < (total - local); ndx++) { 21537c478bd9Sstevel@tonic-gate Sym_desc * wsdp = sort[ndx]; 21547c478bd9Sstevel@tonic-gate Sym * wsym; 21557c478bd9Sstevel@tonic-gate int sndx; 21567c478bd9Sstevel@tonic-gate 21577c478bd9Sstevel@tonic-gate if (wsdp == 0) 21587c478bd9Sstevel@tonic-gate continue; 21597c478bd9Sstevel@tonic-gate 21607c478bd9Sstevel@tonic-gate wsym = wsdp->sd_sym; 21617c478bd9Sstevel@tonic-gate 21627c478bd9Sstevel@tonic-gate if ((ELF_ST_BIND(wsym->st_info) != STB_WEAK) || 21630bc07c75Srie (wsdp->sd_sym->st_shndx == SHN_UNDEF) || 21647c478bd9Sstevel@tonic-gate (wsdp->sd_flags & FLG_SY_SPECSEC)) 21657c478bd9Sstevel@tonic-gate continue; 21667c478bd9Sstevel@tonic-gate 21677c478bd9Sstevel@tonic-gate /* 21687c478bd9Sstevel@tonic-gate * We have a weak symbol, if it has a strong alias it 21697c478bd9Sstevel@tonic-gate * will have been sorted to one of the following sort 21707c478bd9Sstevel@tonic-gate * table entries. Note that we could have multiple weak 21717c478bd9Sstevel@tonic-gate * symbols aliased to one strong (if this occurs then 21727c478bd9Sstevel@tonic-gate * the strong symbol only maintains one alias back to 21737c478bd9Sstevel@tonic-gate * the last weak). 21747c478bd9Sstevel@tonic-gate */ 21757c478bd9Sstevel@tonic-gate for (sndx = ndx + 1; sndx < (total - local); sndx++) { 21767c478bd9Sstevel@tonic-gate Sym_desc * ssdp = sort[sndx]; 21777c478bd9Sstevel@tonic-gate Sym * ssym; 21787c478bd9Sstevel@tonic-gate 21797c478bd9Sstevel@tonic-gate if (ssdp == 0) 21807c478bd9Sstevel@tonic-gate break; 21817c478bd9Sstevel@tonic-gate 21827c478bd9Sstevel@tonic-gate ssym = ssdp->sd_sym; 21837c478bd9Sstevel@tonic-gate 21847c478bd9Sstevel@tonic-gate if (wsym->st_value != ssym->st_value) 21857c478bd9Sstevel@tonic-gate break; 21867c478bd9Sstevel@tonic-gate 21877c478bd9Sstevel@tonic-gate if ((ssdp->sd_file == ifl) && 21887c478bd9Sstevel@tonic-gate (wsdp->sd_file == ifl) && 21897c478bd9Sstevel@tonic-gate (wsym->st_size == ssym->st_size) && 21900bc07c75Srie (ssdp->sd_sym->st_shndx != SHN_UNDEF) && 21917c478bd9Sstevel@tonic-gate (ELF_ST_BIND(ssym->st_info) != STB_WEAK) && 21927c478bd9Sstevel@tonic-gate ((ssdp->sd_flags & FLG_SY_SPECSEC) == 0)) { 21937c478bd9Sstevel@tonic-gate ssdp->sd_aux->sa_linkndx = 21947c478bd9Sstevel@tonic-gate (Word)wsdp->sd_symndx; 21957c478bd9Sstevel@tonic-gate wsdp->sd_aux->sa_linkndx = 21967c478bd9Sstevel@tonic-gate (Word)ssdp->sd_symndx; 21977c478bd9Sstevel@tonic-gate break; 21987c478bd9Sstevel@tonic-gate } 21997c478bd9Sstevel@tonic-gate } 22007c478bd9Sstevel@tonic-gate } 22017c478bd9Sstevel@tonic-gate } 22027c478bd9Sstevel@tonic-gate return (1); 220375e45495Sab 220475e45495Sab #undef SYM_LOC_BADADDR 22057c478bd9Sstevel@tonic-gate } 22067c478bd9Sstevel@tonic-gate 22077c478bd9Sstevel@tonic-gate /* 22087c478bd9Sstevel@tonic-gate * Add an undefined symbol to the symbol table (ie. from -u name option) 22097c478bd9Sstevel@tonic-gate */ 22107c478bd9Sstevel@tonic-gate Sym_desc * 22115aefb655Srie ld_sym_add_u(const char *name, Ofl_desc *ofl) 22127c478bd9Sstevel@tonic-gate { 22137c478bd9Sstevel@tonic-gate Sym *sym; 22147c478bd9Sstevel@tonic-gate Ifl_desc *ifl = 0, *_ifl; 22157c478bd9Sstevel@tonic-gate Sym_desc *sdp; 22167c478bd9Sstevel@tonic-gate Word hash; 22177c478bd9Sstevel@tonic-gate Listnode *lnp; 22187c478bd9Sstevel@tonic-gate avl_index_t where; 22197c478bd9Sstevel@tonic-gate const char *cmdline = MSG_INTL(MSG_STR_COMMAND); 22207c478bd9Sstevel@tonic-gate 22217c478bd9Sstevel@tonic-gate /* 22227c478bd9Sstevel@tonic-gate * If the symbol reference already exists indicate that a reference 22237c478bd9Sstevel@tonic-gate * also came from the command line. 22247c478bd9Sstevel@tonic-gate */ 22257c478bd9Sstevel@tonic-gate /* LINTED */ 22267c478bd9Sstevel@tonic-gate hash = (Word)elf_hash(name); 22275aefb655Srie if (sdp = ld_sym_find(name, hash, &where, ofl)) { 22287c478bd9Sstevel@tonic-gate if (sdp->sd_ref == REF_DYN_SEEN) 22297c478bd9Sstevel@tonic-gate sdp->sd_ref = REF_DYN_NEED; 22307c478bd9Sstevel@tonic-gate return (sdp); 22317c478bd9Sstevel@tonic-gate } 22327c478bd9Sstevel@tonic-gate 22337c478bd9Sstevel@tonic-gate /* 22347c478bd9Sstevel@tonic-gate * Determine whether a pseudo input file descriptor exists to represent 22357c478bd9Sstevel@tonic-gate * the command line, as any global symbol needs an input file descriptor 22367c478bd9Sstevel@tonic-gate * during any symbol resolution (refer to map_ifl() which provides a 22377c478bd9Sstevel@tonic-gate * similar method for adding symbols from mapfiles). 22387c478bd9Sstevel@tonic-gate */ 22397c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&ofl->ofl_objs, lnp, _ifl)) 22407c478bd9Sstevel@tonic-gate if (strcmp(_ifl->ifl_name, cmdline) == 0) { 22417c478bd9Sstevel@tonic-gate ifl = _ifl; 22427c478bd9Sstevel@tonic-gate break; 22437c478bd9Sstevel@tonic-gate } 22447c478bd9Sstevel@tonic-gate 22457c478bd9Sstevel@tonic-gate /* 22467c478bd9Sstevel@tonic-gate * If no descriptor exists create one. 22477c478bd9Sstevel@tonic-gate */ 22487c478bd9Sstevel@tonic-gate if (ifl == 0) { 22497c478bd9Sstevel@tonic-gate if ((ifl = libld_calloc(sizeof (Ifl_desc), 1)) == 22507c478bd9Sstevel@tonic-gate (Ifl_desc *)0) 22517c478bd9Sstevel@tonic-gate return ((Sym_desc *)S_ERROR); 22527c478bd9Sstevel@tonic-gate ifl->ifl_name = cmdline; 22537c478bd9Sstevel@tonic-gate ifl->ifl_flags = FLG_IF_NEEDED | FLG_IF_FILEREF; 22547c478bd9Sstevel@tonic-gate if ((ifl->ifl_ehdr = libld_calloc(sizeof (Ehdr), 22557c478bd9Sstevel@tonic-gate 1)) == 0) 22567c478bd9Sstevel@tonic-gate return ((Sym_desc *)S_ERROR); 22577c478bd9Sstevel@tonic-gate ifl->ifl_ehdr->e_type = ET_REL; 22587c478bd9Sstevel@tonic-gate 22597c478bd9Sstevel@tonic-gate if (list_appendc(&ofl->ofl_objs, ifl) == 0) 22607c478bd9Sstevel@tonic-gate return ((Sym_desc *)S_ERROR); 22617c478bd9Sstevel@tonic-gate } 22627c478bd9Sstevel@tonic-gate 22637c478bd9Sstevel@tonic-gate /* 22647c478bd9Sstevel@tonic-gate * Allocate a symbol structure and add it to the global symbol table. 22657c478bd9Sstevel@tonic-gate */ 22667c478bd9Sstevel@tonic-gate if ((sym = libld_calloc(sizeof (Sym), 1)) == 0) 22677c478bd9Sstevel@tonic-gate return ((Sym_desc *)S_ERROR); 22687c478bd9Sstevel@tonic-gate sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE); 22697c478bd9Sstevel@tonic-gate sym->st_shndx = SHN_UNDEF; 22707c478bd9Sstevel@tonic-gate 22715aefb655Srie DBG_CALL(Dbg_syms_process(ofl->ofl_lml, ifl)); 22725aefb655Srie DBG_CALL(Dbg_syms_global(ofl->ofl_lml, 0, name)); 22735aefb655Srie sdp = ld_sym_enter(name, sym, hash, ifl, ofl, 0, SHN_UNDEF, 22745aefb655Srie 0, 0, &where); 22757c478bd9Sstevel@tonic-gate sdp->sd_flags &= ~FLG_SY_CLEAN; 22767c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_CMDREF; 22777c478bd9Sstevel@tonic-gate 22787c478bd9Sstevel@tonic-gate return (sdp); 22797c478bd9Sstevel@tonic-gate } 2280