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 5*5aefb655Srie * Common Development and Distribution License (the "License"). 6*5aefb655Srie * 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 */ 21*5aefb655Srie 227c478bd9Sstevel@tonic-gate /* 23*5aefb655Srie * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 257c478bd9Sstevel@tonic-gate */ 267c478bd9Sstevel@tonic-gate #pragma ident "%Z%%M% %I% %E% SMI" 277c478bd9Sstevel@tonic-gate 287c478bd9Sstevel@tonic-gate #include <string.h> 297c478bd9Sstevel@tonic-gate #include <stdio.h> 30*5aefb655Srie #include <debug.h> 317c478bd9Sstevel@tonic-gate #include "msg.h" 327c478bd9Sstevel@tonic-gate #include "_libld.h" 337c478bd9Sstevel@tonic-gate 347c478bd9Sstevel@tonic-gate 357c478bd9Sstevel@tonic-gate /* 367c478bd9Sstevel@tonic-gate * Locate a version descriptor. 377c478bd9Sstevel@tonic-gate */ 387c478bd9Sstevel@tonic-gate Ver_desc * 39*5aefb655Srie ld_vers_find(const char *name, Word hash, List *lst) 407c478bd9Sstevel@tonic-gate { 417c478bd9Sstevel@tonic-gate Listnode *lnp; 427c478bd9Sstevel@tonic-gate Ver_desc *vdp; 437c478bd9Sstevel@tonic-gate 447c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(lst, lnp, vdp)) { 457c478bd9Sstevel@tonic-gate if (vdp->vd_hash != hash) 467c478bd9Sstevel@tonic-gate continue; 477c478bd9Sstevel@tonic-gate if (strcmp(vdp->vd_name, name) == 0) 487c478bd9Sstevel@tonic-gate return (vdp); 497c478bd9Sstevel@tonic-gate } 507c478bd9Sstevel@tonic-gate return (0); 517c478bd9Sstevel@tonic-gate } 527c478bd9Sstevel@tonic-gate 537c478bd9Sstevel@tonic-gate /* 547c478bd9Sstevel@tonic-gate * Add a new version descriptor to a version descriptor list. Note, users of 557c478bd9Sstevel@tonic-gate * this are responsible for determining if the version descriptor already 567c478bd9Sstevel@tonic-gate * exists (this can reduce the need to allocate storage for descriptor names 577c478bd9Sstevel@tonic-gate * until it is determined a descriptor need be created (see map_symbol())). 587c478bd9Sstevel@tonic-gate */ 597c478bd9Sstevel@tonic-gate Ver_desc * 60*5aefb655Srie ld_vers_desc(const char *name, Word hash, List *lst) 617c478bd9Sstevel@tonic-gate { 627c478bd9Sstevel@tonic-gate Ver_desc *vdp; 637c478bd9Sstevel@tonic-gate 647c478bd9Sstevel@tonic-gate if ((vdp = libld_calloc(sizeof (Ver_desc), 1)) == 0) 657c478bd9Sstevel@tonic-gate return ((Ver_desc *)S_ERROR); 667c478bd9Sstevel@tonic-gate 677c478bd9Sstevel@tonic-gate vdp->vd_name = name; 687c478bd9Sstevel@tonic-gate vdp->vd_hash = hash; 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate if (list_appendc(lst, vdp) == 0) 717c478bd9Sstevel@tonic-gate return ((Ver_desc *)S_ERROR); 727c478bd9Sstevel@tonic-gate else 737c478bd9Sstevel@tonic-gate return (vdp); 747c478bd9Sstevel@tonic-gate } 757c478bd9Sstevel@tonic-gate 767c478bd9Sstevel@tonic-gate /* 777c478bd9Sstevel@tonic-gate * Now that all explict files have been processed validate any version 787c478bd9Sstevel@tonic-gate * definitions. Insure that any version references are available (a version 797c478bd9Sstevel@tonic-gate * has been defined when it's been assigned an index). Also calculate the 807c478bd9Sstevel@tonic-gate * number of .version section entries that will be required to hold this 817c478bd9Sstevel@tonic-gate * information. 827c478bd9Sstevel@tonic-gate */ 837c478bd9Sstevel@tonic-gate #define _NUM_OF_VERS_ 40 /* twice as big as the depth for libc version */ 847c478bd9Sstevel@tonic-gate typedef struct { 857c478bd9Sstevel@tonic-gate Ver_desc **ver_stk; 867c478bd9Sstevel@tonic-gate int ver_sp; 877c478bd9Sstevel@tonic-gate int ver_lmt; 887c478bd9Sstevel@tonic-gate } Ver_Stack; 897c478bd9Sstevel@tonic-gate 907c478bd9Sstevel@tonic-gate static uintptr_t 91*5aefb655Srie vers_visit_children(Ofl_desc *ofl, Ver_desc *vp, int flag) 927c478bd9Sstevel@tonic-gate { 937c478bd9Sstevel@tonic-gate Listnode *lnp1; 947c478bd9Sstevel@tonic-gate Ver_desc *vdp; 957c478bd9Sstevel@tonic-gate static int err = 0; 967c478bd9Sstevel@tonic-gate static Ver_Stack ver_stk = {0, 0, 0}; 977c478bd9Sstevel@tonic-gate int tmp_sp; 987c478bd9Sstevel@tonic-gate 997c478bd9Sstevel@tonic-gate /* 1007c478bd9Sstevel@tonic-gate * If there was any fatal error, 1017c478bd9Sstevel@tonic-gate * just return. 1027c478bd9Sstevel@tonic-gate */ 1037c478bd9Sstevel@tonic-gate if (err == S_ERROR) 1047c478bd9Sstevel@tonic-gate return (err); 1057c478bd9Sstevel@tonic-gate 1067c478bd9Sstevel@tonic-gate /* 1077c478bd9Sstevel@tonic-gate * if this is called from, ver_check_defs(), initialize sp. 1087c478bd9Sstevel@tonic-gate */ 1097c478bd9Sstevel@tonic-gate if (flag == 0) 1107c478bd9Sstevel@tonic-gate ver_stk.ver_sp = 0; 1117c478bd9Sstevel@tonic-gate 1127c478bd9Sstevel@tonic-gate /* 1137c478bd9Sstevel@tonic-gate * Check if passed version pointer vp is already in the stack. 1147c478bd9Sstevel@tonic-gate */ 1157c478bd9Sstevel@tonic-gate for (tmp_sp = 0; tmp_sp < ver_stk.ver_sp; tmp_sp++) { 1167c478bd9Sstevel@tonic-gate Ver_desc *v; 1177c478bd9Sstevel@tonic-gate 1187c478bd9Sstevel@tonic-gate v = ver_stk.ver_stk[tmp_sp]; 1197c478bd9Sstevel@tonic-gate if (v == vp) { 1207c478bd9Sstevel@tonic-gate /* 1217c478bd9Sstevel@tonic-gate * cyclic dependency. 1227c478bd9Sstevel@tonic-gate */ 1237c478bd9Sstevel@tonic-gate if (err == 0) { 124*5aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 125*5aefb655Srie MSG_INTL(MSG_VER_CYCLIC)); 1267c478bd9Sstevel@tonic-gate err = 1; 1277c478bd9Sstevel@tonic-gate } 1287c478bd9Sstevel@tonic-gate for (tmp_sp = 0; tmp_sp < ver_stk.ver_sp; tmp_sp++) { 1297c478bd9Sstevel@tonic-gate v = ver_stk.ver_stk[tmp_sp]; 1307c478bd9Sstevel@tonic-gate if ((v->vd_flags & FLG_VER_CYCLIC) == 0) { 1317c478bd9Sstevel@tonic-gate v->vd_flags |= FLG_VER_CYCLIC; 132*5aefb655Srie eprintf(ofl->ofl_lml, ERR_NONE, 133*5aefb655Srie MSG_INTL(MSG_VER_ADDVER), 134*5aefb655Srie v->vd_name); 1357c478bd9Sstevel@tonic-gate } 1367c478bd9Sstevel@tonic-gate } 1377c478bd9Sstevel@tonic-gate if ((vp->vd_flags & FLG_VER_CYCLIC) == 0) { 1387c478bd9Sstevel@tonic-gate vp->vd_flags |= FLG_VER_CYCLIC; 139*5aefb655Srie eprintf(ofl->ofl_lml, ERR_NONE, 140*5aefb655Srie MSG_INTL(MSG_VER_ADDVER), vp->vd_name); 1417c478bd9Sstevel@tonic-gate } 1427c478bd9Sstevel@tonic-gate return (err); 1437c478bd9Sstevel@tonic-gate } 1447c478bd9Sstevel@tonic-gate } 1457c478bd9Sstevel@tonic-gate 1467c478bd9Sstevel@tonic-gate /* 1477c478bd9Sstevel@tonic-gate * Push version on the stack. 1487c478bd9Sstevel@tonic-gate */ 1497c478bd9Sstevel@tonic-gate if (ver_stk.ver_sp >= ver_stk.ver_lmt) { 1507c478bd9Sstevel@tonic-gate ver_stk.ver_lmt += _NUM_OF_VERS_; 1517c478bd9Sstevel@tonic-gate if ((ver_stk.ver_stk = (Ver_desc **) 1527c478bd9Sstevel@tonic-gate libld_realloc((void *)ver_stk.ver_stk, 1537c478bd9Sstevel@tonic-gate ver_stk.ver_lmt * sizeof (Ver_desc *))) == NULL) 1547c478bd9Sstevel@tonic-gate return (S_ERROR); 1557c478bd9Sstevel@tonic-gate } 1567c478bd9Sstevel@tonic-gate ver_stk.ver_stk[(ver_stk.ver_sp)++] = vp; 1577c478bd9Sstevel@tonic-gate 1587c478bd9Sstevel@tonic-gate /* 1597c478bd9Sstevel@tonic-gate * Now visit children. 1607c478bd9Sstevel@tonic-gate */ 1617c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&vp->vd_deps, lnp1, vdp)) 162*5aefb655Srie if (vers_visit_children(ofl, vdp, 1) == S_ERROR) 1637c478bd9Sstevel@tonic-gate return (S_ERROR); 1647c478bd9Sstevel@tonic-gate 1657c478bd9Sstevel@tonic-gate /* 1667c478bd9Sstevel@tonic-gate * Pop version from the stack. 1677c478bd9Sstevel@tonic-gate */ 1687c478bd9Sstevel@tonic-gate (ver_stk.ver_sp)--; 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate return (err); 1717c478bd9Sstevel@tonic-gate } 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate uintptr_t 174*5aefb655Srie ld_vers_check_defs(Ofl_desc *ofl) 1757c478bd9Sstevel@tonic-gate { 1767c478bd9Sstevel@tonic-gate Listnode *lnp1, *lnp2; 1777c478bd9Sstevel@tonic-gate Ver_desc *vdp; 1787c478bd9Sstevel@tonic-gate uintptr_t is_cyclic = 0; 1797c478bd9Sstevel@tonic-gate 1807c478bd9Sstevel@tonic-gate 181*5aefb655Srie DBG_CALL(Dbg_ver_def_title(ofl->ofl_lml, ofl->ofl_name)); 1827c478bd9Sstevel@tonic-gate 1837c478bd9Sstevel@tonic-gate /* 1847c478bd9Sstevel@tonic-gate * First check if there are any cyclic dependency 1857c478bd9Sstevel@tonic-gate */ 1867c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&ofl->ofl_verdesc, lnp1, vdp)) 187*5aefb655Srie if ((is_cyclic = vers_visit_children(ofl, vdp, 0)) == S_ERROR) 1887c478bd9Sstevel@tonic-gate return (S_ERROR); 1897c478bd9Sstevel@tonic-gate if (is_cyclic) 1907c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 1917c478bd9Sstevel@tonic-gate 1927c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&ofl->ofl_verdesc, lnp1, vdp)) { 1937c478bd9Sstevel@tonic-gate Byte cnt; 1947c478bd9Sstevel@tonic-gate Sym *sym; 1957c478bd9Sstevel@tonic-gate Sym_desc *sdp; 1967c478bd9Sstevel@tonic-gate const char *name = vdp->vd_name; 1977c478bd9Sstevel@tonic-gate unsigned char bind; 1987c478bd9Sstevel@tonic-gate Ver_desc *_vdp; 1997c478bd9Sstevel@tonic-gate avl_index_t where; 2007c478bd9Sstevel@tonic-gate 2017c478bd9Sstevel@tonic-gate if (vdp->vd_ndx == 0) { 202*5aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 203*5aefb655Srie MSG_INTL(MSG_VER_UNDEF), name, vdp->vd_ref->vd_name, 2047c478bd9Sstevel@tonic-gate vdp->vd_ref->vd_file->ifl_name); 2057c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 2067c478bd9Sstevel@tonic-gate continue; 2077c478bd9Sstevel@tonic-gate } 2087c478bd9Sstevel@tonic-gate 209*5aefb655Srie DBG_CALL(Dbg_ver_desc_entry(ofl->ofl_lml, vdp)); 2107c478bd9Sstevel@tonic-gate 2117c478bd9Sstevel@tonic-gate /* 2127c478bd9Sstevel@tonic-gate * If a version definition contains no symbols this is possibly 2137c478bd9Sstevel@tonic-gate * a mapfile error. 2147c478bd9Sstevel@tonic-gate */ 2157c478bd9Sstevel@tonic-gate if ((vdp->vd_flags & 2167c478bd9Sstevel@tonic-gate (VER_FLG_BASE | VER_FLG_WEAK | FLG_VER_REFER)) == 0) 217*5aefb655Srie DBG_CALL(Dbg_ver_nointerface(ofl->ofl_lml, 218*5aefb655Srie vdp->vd_name)); 2197c478bd9Sstevel@tonic-gate 2207c478bd9Sstevel@tonic-gate /* 2217c478bd9Sstevel@tonic-gate * Update the version entry count to account for this new 2227c478bd9Sstevel@tonic-gate * version descriptor (the count is the size in bytes). 2237c478bd9Sstevel@tonic-gate */ 2247c478bd9Sstevel@tonic-gate ofl->ofl_verdefsz += sizeof (Verdef); 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate /* 2277c478bd9Sstevel@tonic-gate * Traverse this versions dependency list to determine what 2287c478bd9Sstevel@tonic-gate * additional version dependencies we must account for against 2297c478bd9Sstevel@tonic-gate * this descriptor. 2307c478bd9Sstevel@tonic-gate */ 2317c478bd9Sstevel@tonic-gate cnt = 1; 2327c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&vdp->vd_deps, lnp2, _vdp)) { 2337c478bd9Sstevel@tonic-gate #if defined(__lint) 2347c478bd9Sstevel@tonic-gate /* get lint to think `_vdp' is used... */ 2357c478bd9Sstevel@tonic-gate lnp2 = (Listnode *)_vdp; 2367c478bd9Sstevel@tonic-gate #endif 2377c478bd9Sstevel@tonic-gate cnt++; 2387c478bd9Sstevel@tonic-gate } 2397c478bd9Sstevel@tonic-gate ofl->ofl_verdefsz += (cnt * sizeof (Verdaux)); 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate /* 2427c478bd9Sstevel@tonic-gate * Except for the base version descriptor, generate an absolute 2437c478bd9Sstevel@tonic-gate * symbol to reflect this version. 2447c478bd9Sstevel@tonic-gate */ 2457c478bd9Sstevel@tonic-gate if (vdp->vd_flags & VER_FLG_BASE) 2467c478bd9Sstevel@tonic-gate continue; 2477c478bd9Sstevel@tonic-gate 2487c478bd9Sstevel@tonic-gate if (vdp->vd_flags & VER_FLG_WEAK) 2497c478bd9Sstevel@tonic-gate bind = STB_WEAK; 2507c478bd9Sstevel@tonic-gate else 2517c478bd9Sstevel@tonic-gate bind = STB_GLOBAL; 2527c478bd9Sstevel@tonic-gate 253*5aefb655Srie if (sdp = ld_sym_find(name, vdp->vd_hash, &where, ofl)) { 2547c478bd9Sstevel@tonic-gate /* 2557c478bd9Sstevel@tonic-gate * If the symbol already exists and is undefined or was 2567c478bd9Sstevel@tonic-gate * defined in a shared library, convert it to an 2577c478bd9Sstevel@tonic-gate * absolute. 2587c478bd9Sstevel@tonic-gate */ 2597c478bd9Sstevel@tonic-gate if ((sdp->sd_shndx == SHN_UNDEF) || 2607c478bd9Sstevel@tonic-gate (sdp->sd_ref != REF_REL_NEED)) { 2617c478bd9Sstevel@tonic-gate sdp->sd_shndx = sdp->sd_sym->st_shndx = SHN_ABS; 2627c478bd9Sstevel@tonic-gate sdp->sd_sym->st_info = 2637c478bd9Sstevel@tonic-gate ELF_ST_INFO(bind, STT_OBJECT); 2647c478bd9Sstevel@tonic-gate sdp->sd_ref = REF_REL_NEED; 2657c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_SPECSEC; 2667c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_GLOB; 2677c478bd9Sstevel@tonic-gate sdp->sd_aux->sa_overndx = vdp->vd_ndx; 2687c478bd9Sstevel@tonic-gate 2697c478bd9Sstevel@tonic-gate /* 2707c478bd9Sstevel@tonic-gate * If the reference originated from a mapfile 2717c478bd9Sstevel@tonic-gate * insure we mark the symbol as used. 2727c478bd9Sstevel@tonic-gate */ 2737c478bd9Sstevel@tonic-gate if (sdp->sd_flags & FLG_SY_MAPREF) 2747c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_MAPUSED; 2757c478bd9Sstevel@tonic-gate 2767c478bd9Sstevel@tonic-gate } else if ((sdp->sd_flags & FLG_SY_SPECSEC) && 2777c478bd9Sstevel@tonic-gate (sdp->sd_shndx != SHN_ABS) && 2787c478bd9Sstevel@tonic-gate (sdp->sd_ref == REF_REL_NEED)) { 279*5aefb655Srie eprintf(ofl->ofl_lml, ERR_WARNING, 280*5aefb655Srie MSG_INTL(MSG_VER_DEFINED), name, 281*5aefb655Srie sdp->sd_file->ifl_name); 2827c478bd9Sstevel@tonic-gate } 2837c478bd9Sstevel@tonic-gate } else { 2847c478bd9Sstevel@tonic-gate /* 2857c478bd9Sstevel@tonic-gate * If the symbol does not exist create it. 2867c478bd9Sstevel@tonic-gate */ 2877c478bd9Sstevel@tonic-gate if ((sym = libld_calloc(sizeof (Sym), 1)) == 0) 2887c478bd9Sstevel@tonic-gate return (S_ERROR); 2897c478bd9Sstevel@tonic-gate sym->st_shndx = SHN_ABS; 2907c478bd9Sstevel@tonic-gate sym->st_info = ELF_ST_INFO(bind, STT_OBJECT); 291*5aefb655Srie DBG_CALL(Dbg_ver_symbol(ofl->ofl_lml, name)); 292*5aefb655Srie if ((sdp = ld_sym_enter(name, sym, vdp->vd_hash, 2937c478bd9Sstevel@tonic-gate vdp->vd_file, ofl, 0, SHN_ABS, FLG_SY_SPECSEC, 2947c478bd9Sstevel@tonic-gate FLG_SY1_GLOB, &where)) == (Sym_desc *)S_ERROR) 2957c478bd9Sstevel@tonic-gate return (S_ERROR); 2967c478bd9Sstevel@tonic-gate sdp->sd_ref = REF_REL_NEED; 2977c478bd9Sstevel@tonic-gate sdp->sd_aux->sa_overndx = vdp->vd_ndx; 2987c478bd9Sstevel@tonic-gate } 2997c478bd9Sstevel@tonic-gate } 3007c478bd9Sstevel@tonic-gate return (1); 3017c478bd9Sstevel@tonic-gate } 3027c478bd9Sstevel@tonic-gate 3037c478bd9Sstevel@tonic-gate /* 3047c478bd9Sstevel@tonic-gate * Dereference dependencies as a part of normalizing (allows recursion). 3057c478bd9Sstevel@tonic-gate */ 306*5aefb655Srie static void 3077c478bd9Sstevel@tonic-gate vers_derefer(Ifl_desc *ifl, Ver_desc *vdp, int weak) 3087c478bd9Sstevel@tonic-gate { 3097c478bd9Sstevel@tonic-gate Listnode *lnp; 3107c478bd9Sstevel@tonic-gate Ver_desc *_vdp; 3117c478bd9Sstevel@tonic-gate Ver_index *vip = &ifl->ifl_verndx[vdp->vd_ndx]; 3127c478bd9Sstevel@tonic-gate 3137c478bd9Sstevel@tonic-gate /* 3147c478bd9Sstevel@tonic-gate * If the head of the list was a weak then we only clear out 3157c478bd9Sstevel@tonic-gate * weak dependencies, but if the head of the list was 'strong' 3167c478bd9Sstevel@tonic-gate * we clear the REFER bit on all dependencies. 3177c478bd9Sstevel@tonic-gate */ 3187c478bd9Sstevel@tonic-gate if ((weak && (vdp->vd_flags & VER_FLG_WEAK)) || (!weak)) 3197c478bd9Sstevel@tonic-gate vip->vi_flags &= ~FLG_VER_REFER; 3207c478bd9Sstevel@tonic-gate 3217c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&vdp->vd_deps, lnp, _vdp)) 3227c478bd9Sstevel@tonic-gate vers_derefer(ifl, _vdp, weak); 3237c478bd9Sstevel@tonic-gate } 3247c478bd9Sstevel@tonic-gate 3257c478bd9Sstevel@tonic-gate /* 3267c478bd9Sstevel@tonic-gate * If we need to record the versions of any needed dependencies traverse the 3277c478bd9Sstevel@tonic-gate * shared object dependency list and calculate what version needed entries are 3287c478bd9Sstevel@tonic-gate * required. 3297c478bd9Sstevel@tonic-gate */ 3307c478bd9Sstevel@tonic-gate uintptr_t 331*5aefb655Srie ld_vers_check_need(Ofl_desc *ofl) 3327c478bd9Sstevel@tonic-gate { 3337c478bd9Sstevel@tonic-gate Listnode *lnp1; 3347c478bd9Sstevel@tonic-gate Ifl_desc *ifl; 3357c478bd9Sstevel@tonic-gate 3367c478bd9Sstevel@tonic-gate /* 3377c478bd9Sstevel@tonic-gate * Traverse the shared object list looking for dependencies. 3387c478bd9Sstevel@tonic-gate */ 3397c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&ofl->ofl_sos, lnp1, ifl)) { 3407c478bd9Sstevel@tonic-gate Listnode *lnp2; 3417c478bd9Sstevel@tonic-gate Ver_index *vip; 3427c478bd9Sstevel@tonic-gate Ver_desc *vdp; 3437c478bd9Sstevel@tonic-gate Sdf_desc *sdf = ifl->ifl_sdfdesc; 3447c478bd9Sstevel@tonic-gate Byte cnt, need; 3457c478bd9Sstevel@tonic-gate 3467c478bd9Sstevel@tonic-gate if (!(ifl->ifl_flags & FLG_IF_NEEDED)) 3477c478bd9Sstevel@tonic-gate continue; 3487c478bd9Sstevel@tonic-gate 3497c478bd9Sstevel@tonic-gate if (ifl->ifl_vercnt <= VER_NDX_GLOBAL) 3507c478bd9Sstevel@tonic-gate continue; 3517c478bd9Sstevel@tonic-gate 3527c478bd9Sstevel@tonic-gate /* 3537c478bd9Sstevel@tonic-gate * If version needed definitions were specified in 3547c478bd9Sstevel@tonic-gate * a mapfile ($SPECVERS=) then record those definitions 3557c478bd9Sstevel@tonic-gate */ 3567c478bd9Sstevel@tonic-gate if (sdf && (sdf->sdf_flags & FLG_SDF_SPECVER)) { 3577c478bd9Sstevel@tonic-gate Sdv_desc *sdv; 3587c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&sdf->sdf_verneed, lnp2, 3597c478bd9Sstevel@tonic-gate sdv)) { 3607c478bd9Sstevel@tonic-gate ofl->ofl_verneedsz += sizeof (Vernaux); 3617c478bd9Sstevel@tonic-gate if (st_insert(ofl->ofl_dynstrtab, 3627c478bd9Sstevel@tonic-gate sdv->sdv_name) == -1) 3637c478bd9Sstevel@tonic-gate return (S_ERROR); 3647c478bd9Sstevel@tonic-gate } 3657c478bd9Sstevel@tonic-gate ifl->ifl_flags |= FLG_IF_VERNEED; 3667c478bd9Sstevel@tonic-gate ofl->ofl_verneedsz += sizeof (Verneed); 3677c478bd9Sstevel@tonic-gate if (st_insert(ofl->ofl_dynstrtab, 3687c478bd9Sstevel@tonic-gate ifl->ifl_soname) == -1) 3697c478bd9Sstevel@tonic-gate return (S_ERROR); 3707c478bd9Sstevel@tonic-gate continue; 3717c478bd9Sstevel@tonic-gate } 3727c478bd9Sstevel@tonic-gate 3737c478bd9Sstevel@tonic-gate /* 3747c478bd9Sstevel@tonic-gate * Scan the version index list and if any weak version 3757c478bd9Sstevel@tonic-gate * definition has been referenced by the user promote the 3767c478bd9Sstevel@tonic-gate * dependency to be non-weak. Weak version dependencies do not 3777c478bd9Sstevel@tonic-gate * cause fatal errors from the runtime linker, non-weak 3787c478bd9Sstevel@tonic-gate * dependencies do. 3797c478bd9Sstevel@tonic-gate */ 3807c478bd9Sstevel@tonic-gate for (need = 0, cnt = 0; cnt <= ifl->ifl_vercnt; cnt++) { 3817c478bd9Sstevel@tonic-gate vip = &ifl->ifl_verndx[cnt]; 3827c478bd9Sstevel@tonic-gate vdp = vip->vi_desc; 3837c478bd9Sstevel@tonic-gate 3847c478bd9Sstevel@tonic-gate if ((vip->vi_flags & (FLG_VER_REFER | VER_FLG_WEAK)) == 3857c478bd9Sstevel@tonic-gate (FLG_VER_REFER | VER_FLG_WEAK)) 3867c478bd9Sstevel@tonic-gate vdp->vd_flags &= ~VER_FLG_WEAK; 3877c478bd9Sstevel@tonic-gate 3887c478bd9Sstevel@tonic-gate /* 3897c478bd9Sstevel@tonic-gate * Mark any weak reference as referred to so as to 3907c478bd9Sstevel@tonic-gate * simplify normalization and later version dependency 3917c478bd9Sstevel@tonic-gate * manipulation. 3927c478bd9Sstevel@tonic-gate */ 3937c478bd9Sstevel@tonic-gate if (vip->vi_flags & VER_FLG_WEAK) 3947c478bd9Sstevel@tonic-gate vip->vi_flags |= FLG_VER_REFER; 3957c478bd9Sstevel@tonic-gate } 3967c478bd9Sstevel@tonic-gate 3977c478bd9Sstevel@tonic-gate /* 3987c478bd9Sstevel@tonic-gate * Scan the version dependency list to normalize the referenced 3997c478bd9Sstevel@tonic-gate * dependencies. Any needed version that is inherited by 4007c478bd9Sstevel@tonic-gate * another like version is derefereced as it is not necessary 4017c478bd9Sstevel@tonic-gate * to make this part of the version dependencies. 4027c478bd9Sstevel@tonic-gate */ 4037c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&ifl->ifl_verdesc, lnp2, vdp)) { 4047c478bd9Sstevel@tonic-gate Listnode *lnp3; 4057c478bd9Sstevel@tonic-gate Ver_desc *_vdp; 4067c478bd9Sstevel@tonic-gate int type; 4077c478bd9Sstevel@tonic-gate 4087c478bd9Sstevel@tonic-gate vip = &ifl->ifl_verndx[vdp->vd_ndx]; 4097c478bd9Sstevel@tonic-gate 4107c478bd9Sstevel@tonic-gate if (!(vip->vi_flags & FLG_VER_REFER)) 4117c478bd9Sstevel@tonic-gate continue; 4127c478bd9Sstevel@tonic-gate 4137c478bd9Sstevel@tonic-gate type = vdp->vd_flags & VER_FLG_WEAK; 4147c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&vdp->vd_deps, lnp3, _vdp)) 4157c478bd9Sstevel@tonic-gate vers_derefer(ifl, _vdp, type); 4167c478bd9Sstevel@tonic-gate } 4177c478bd9Sstevel@tonic-gate 4187c478bd9Sstevel@tonic-gate /* 4197c478bd9Sstevel@tonic-gate * Finally, determine how many of the version dependencies need 4207c478bd9Sstevel@tonic-gate * to be recorded. 4217c478bd9Sstevel@tonic-gate */ 4227c478bd9Sstevel@tonic-gate for (need = 0, cnt = 0; cnt <= ifl->ifl_vercnt; cnt++) { 4237c478bd9Sstevel@tonic-gate vip = &ifl->ifl_verndx[cnt]; 4247c478bd9Sstevel@tonic-gate 4257c478bd9Sstevel@tonic-gate /* 4267c478bd9Sstevel@tonic-gate * If a version has been referenced then record it as a 4277c478bd9Sstevel@tonic-gate * version dependency. 4287c478bd9Sstevel@tonic-gate */ 4297c478bd9Sstevel@tonic-gate if (vip->vi_flags & FLG_VER_REFER) { 4307c478bd9Sstevel@tonic-gate ofl->ofl_verneedsz += sizeof (Vernaux); 4317c478bd9Sstevel@tonic-gate if (st_insert(ofl->ofl_dynstrtab, 4327c478bd9Sstevel@tonic-gate vip->vi_name) == -1) 4337c478bd9Sstevel@tonic-gate return (S_ERROR); 4347c478bd9Sstevel@tonic-gate need++; 4357c478bd9Sstevel@tonic-gate } 4367c478bd9Sstevel@tonic-gate } 4377c478bd9Sstevel@tonic-gate 4387c478bd9Sstevel@tonic-gate if (need) { 4397c478bd9Sstevel@tonic-gate ifl->ifl_flags |= FLG_IF_VERNEED; 4407c478bd9Sstevel@tonic-gate ofl->ofl_verneedsz += sizeof (Verneed); 4417c478bd9Sstevel@tonic-gate if (st_insert(ofl->ofl_dynstrtab, 4427c478bd9Sstevel@tonic-gate ifl->ifl_soname) == -1) 4437c478bd9Sstevel@tonic-gate return (S_ERROR); 4447c478bd9Sstevel@tonic-gate } 4457c478bd9Sstevel@tonic-gate } 4467c478bd9Sstevel@tonic-gate 4477c478bd9Sstevel@tonic-gate /* 4487c478bd9Sstevel@tonic-gate * If no version needed information is required unset the output file 4497c478bd9Sstevel@tonic-gate * flag. 4507c478bd9Sstevel@tonic-gate */ 4517c478bd9Sstevel@tonic-gate if (ofl->ofl_verneedsz == 0) 4527c478bd9Sstevel@tonic-gate ofl->ofl_flags &= ~FLG_OF_VERNEED; 4537c478bd9Sstevel@tonic-gate 4547c478bd9Sstevel@tonic-gate return (1); 4557c478bd9Sstevel@tonic-gate } 4567c478bd9Sstevel@tonic-gate 4577c478bd9Sstevel@tonic-gate /* 4587c478bd9Sstevel@tonic-gate * Indicate dependency selection (allows recursion). 4597c478bd9Sstevel@tonic-gate */ 460*5aefb655Srie static void 461*5aefb655Srie vers_select(Ofl_desc *ofl, Ifl_desc *ifl, Ver_desc *vdp, const char *ref) 4627c478bd9Sstevel@tonic-gate { 4637c478bd9Sstevel@tonic-gate Listnode *lnp; 4647c478bd9Sstevel@tonic-gate Ver_desc *_vdp; 4657c478bd9Sstevel@tonic-gate Ver_index *vip = &ifl->ifl_verndx[vdp->vd_ndx]; 4667c478bd9Sstevel@tonic-gate 4677c478bd9Sstevel@tonic-gate vip->vi_flags |= FLG_VER_AVAIL; 468*5aefb655Srie DBG_CALL(Dbg_ver_avail_entry(ofl->ofl_lml, vip, ref)); 4697c478bd9Sstevel@tonic-gate 4707c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&vdp->vd_deps, lnp, _vdp)) 471*5aefb655Srie vers_select(ofl, ifl, _vdp, ref); 4727c478bd9Sstevel@tonic-gate } 4737c478bd9Sstevel@tonic-gate 474*5aefb655Srie static Ver_index * 475*5aefb655Srie vers_index(Ofl_desc *ofl, Ifl_desc *ifl, int avail) 4767c478bd9Sstevel@tonic-gate { 4777c478bd9Sstevel@tonic-gate Listnode *lnp; 4787c478bd9Sstevel@tonic-gate Ver_desc *vdp; 4797c478bd9Sstevel@tonic-gate Ver_index *vip; 4807c478bd9Sstevel@tonic-gate Sdf_desc *sdf = ifl->ifl_sdfdesc; 4817c478bd9Sstevel@tonic-gate Word count = ifl->ifl_vercnt; 4827c478bd9Sstevel@tonic-gate Sdv_desc *sdv; 4837c478bd9Sstevel@tonic-gate 4847c478bd9Sstevel@tonic-gate /* 4857c478bd9Sstevel@tonic-gate * Allocate an index array large enough to hold all of the files 4867c478bd9Sstevel@tonic-gate * version descriptors. 4877c478bd9Sstevel@tonic-gate */ 4887c478bd9Sstevel@tonic-gate if ((vip = libld_calloc(sizeof (Ver_index), 4897c478bd9Sstevel@tonic-gate (count + 1))) == 0) 4907c478bd9Sstevel@tonic-gate return ((Ver_index *)S_ERROR); 4917c478bd9Sstevel@tonic-gate 4927c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&ifl->ifl_verdesc, lnp, vdp)) { 4937c478bd9Sstevel@tonic-gate int ndx = vdp->vd_ndx; 4947c478bd9Sstevel@tonic-gate 4957c478bd9Sstevel@tonic-gate vip[ndx].vi_name = vdp->vd_name; 4967c478bd9Sstevel@tonic-gate vip[ndx].vi_desc = vdp; 4977c478bd9Sstevel@tonic-gate 4987c478bd9Sstevel@tonic-gate /* 4997c478bd9Sstevel@tonic-gate * Any relocatable object versions, and the `base' version are 5007c478bd9Sstevel@tonic-gate * always available. 5017c478bd9Sstevel@tonic-gate */ 5027c478bd9Sstevel@tonic-gate if (avail || (vdp->vd_flags & VER_FLG_BASE)) 5037c478bd9Sstevel@tonic-gate vip[ndx].vi_flags |= FLG_VER_AVAIL; 5047c478bd9Sstevel@tonic-gate 5057c478bd9Sstevel@tonic-gate /* 5067c478bd9Sstevel@tonic-gate * If this is a weak version mark it as such. Weak versions 5077c478bd9Sstevel@tonic-gate * are always dragged into any version dependencies created, 5087c478bd9Sstevel@tonic-gate * and if a weak version is referenced it will be promoted to 5097c478bd9Sstevel@tonic-gate * a non-weak version dependency. 5107c478bd9Sstevel@tonic-gate */ 5117c478bd9Sstevel@tonic-gate if (vdp->vd_flags & VER_FLG_WEAK) 5127c478bd9Sstevel@tonic-gate vip[ndx].vi_flags |= VER_FLG_WEAK; 5137c478bd9Sstevel@tonic-gate /* 5147c478bd9Sstevel@tonic-gate * If this version is mentioned in a mapfile 5157c478bd9Sstevel@tonic-gate * $ADDVERS syntax then add a FLG_IF_NEEDED flag now 5167c478bd9Sstevel@tonic-gate */ 5177c478bd9Sstevel@tonic-gate if (sdf && (sdf->sdf_flags & FLG_SDF_ADDVER)) { 5187c478bd9Sstevel@tonic-gate Listnode * lnp2; 5197c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&sdf->sdf_verneed, lnp2, sdv)) { 5207c478bd9Sstevel@tonic-gate if (strcmp(vip[ndx].vi_name, 5217c478bd9Sstevel@tonic-gate sdv->sdv_name) == 0) { 5227c478bd9Sstevel@tonic-gate vip[ndx].vi_flags |= FLG_VER_REFER; 5237c478bd9Sstevel@tonic-gate sdv->sdv_flags |= FLG_SDV_MATCHED; 5247c478bd9Sstevel@tonic-gate break; 5257c478bd9Sstevel@tonic-gate } 5267c478bd9Sstevel@tonic-gate } 5277c478bd9Sstevel@tonic-gate } 5287c478bd9Sstevel@tonic-gate } 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate /* 5317c478bd9Sstevel@tonic-gate * if $ADDVER was specified for this object verify that 5327c478bd9Sstevel@tonic-gate * all of it's dependent upon versions were refered to. 5337c478bd9Sstevel@tonic-gate */ 5347c478bd9Sstevel@tonic-gate if (sdf && (sdf->sdf_flags & FLG_SDF_ADDVER)) { 5357c478bd9Sstevel@tonic-gate int fail = 0; 5367c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&sdf->sdf_verneed, lnp, sdv)) { 5377c478bd9Sstevel@tonic-gate if (!(sdv->sdv_flags & FLG_SDV_MATCHED)) { 5387c478bd9Sstevel@tonic-gate if (fail == 0) { 5397c478bd9Sstevel@tonic-gate fail++; 540*5aefb655Srie eprintf(ofl->ofl_lml, ERR_NONE, 5417c478bd9Sstevel@tonic-gate MSG_INTL(MSG_VER_ADDVERS), 5427c478bd9Sstevel@tonic-gate sdf->sdf_rfile, sdf->sdf_name); 5437c478bd9Sstevel@tonic-gate } 544*5aefb655Srie eprintf(ofl->ofl_lml, ERR_NONE, 545*5aefb655Srie MSG_INTL(MSG_VER_ADDVER), sdv->sdv_name); 5467c478bd9Sstevel@tonic-gate } 5477c478bd9Sstevel@tonic-gate } 5487c478bd9Sstevel@tonic-gate if (fail) 5497c478bd9Sstevel@tonic-gate return ((Ver_index *)S_ERROR); 5507c478bd9Sstevel@tonic-gate } 5517c478bd9Sstevel@tonic-gate 5527c478bd9Sstevel@tonic-gate return (vip); 5537c478bd9Sstevel@tonic-gate } 5547c478bd9Sstevel@tonic-gate 5557c478bd9Sstevel@tonic-gate /* 5567c478bd9Sstevel@tonic-gate * Process a version symbol index section. 5577c478bd9Sstevel@tonic-gate */ 5587c478bd9Sstevel@tonic-gate int 559*5aefb655Srie ld_vers_sym_process(Lm_list *lml, Is_desc *isp, Ifl_desc *ifl) 5607c478bd9Sstevel@tonic-gate { 5617c478bd9Sstevel@tonic-gate Shdr *symshdr; 5627c478bd9Sstevel@tonic-gate Shdr *vershdr = isp->is_shdr; 563*5aefb655Srie 5647c478bd9Sstevel@tonic-gate /* 565*5aefb655Srie * Verify that the versym is the same size as the linked symbol table. 566*5aefb655Srie * If these two get out of sync the file is considered corrupted. 5677c478bd9Sstevel@tonic-gate */ 5687c478bd9Sstevel@tonic-gate symshdr = ifl->ifl_isdesc[vershdr->sh_link]->is_shdr; 5697c478bd9Sstevel@tonic-gate if ((symshdr->sh_size / symshdr->sh_entsize) != (vershdr->sh_size / 5707c478bd9Sstevel@tonic-gate vershdr->sh_entsize)) { 571*5aefb655Srie eprintf(lml, ERR_WARNING, MSG_INTL(MSG_ELF_VERSYM), 572*5aefb655Srie ifl->ifl_name, isp->is_name, 573*5aefb655Srie EC_WORD(vershdr->sh_size / vershdr->sh_entsize), 574*5aefb655Srie ifl->ifl_isdesc[vershdr->sh_link]->is_name, 575*5aefb655Srie EC_WORD(symshdr->sh_size / symshdr->sh_entsize)); 5767c478bd9Sstevel@tonic-gate return (1); 5777c478bd9Sstevel@tonic-gate } 5787c478bd9Sstevel@tonic-gate ifl->ifl_versym = (Versym *)isp->is_indata->d_buf; 5797c478bd9Sstevel@tonic-gate return (1); 5807c478bd9Sstevel@tonic-gate } 5817c478bd9Sstevel@tonic-gate 5827c478bd9Sstevel@tonic-gate /* 5837c478bd9Sstevel@tonic-gate * Process a version definition section from an input file. A list of version 5847c478bd9Sstevel@tonic-gate * descriptors is created and associated with the input files descriptor. If 5857c478bd9Sstevel@tonic-gate * this is a shared object these descriptors will be used to indicate the 5867c478bd9Sstevel@tonic-gate * availability of each version. If this is a relocatable object then these 5877c478bd9Sstevel@tonic-gate * descriptors will be promoted (concatenated) to the output files image. 5887c478bd9Sstevel@tonic-gate */ 5897c478bd9Sstevel@tonic-gate uintptr_t 590*5aefb655Srie ld_vers_def_process(Is_desc *isp, Ifl_desc *ifl, Ofl_desc *ofl) 5917c478bd9Sstevel@tonic-gate { 5927c478bd9Sstevel@tonic-gate const char *str, *file = ifl->ifl_name; 5937c478bd9Sstevel@tonic-gate Sdf_desc *sdf = ifl->ifl_sdfdesc; 5947c478bd9Sstevel@tonic-gate Sdv_desc *sdv; 5957c478bd9Sstevel@tonic-gate Word num, _num; 5967c478bd9Sstevel@tonic-gate Verdef *vdf; 5977c478bd9Sstevel@tonic-gate int relobj; 5987c478bd9Sstevel@tonic-gate 5997c478bd9Sstevel@tonic-gate /* 6007c478bd9Sstevel@tonic-gate * If there is no version section then simply indicate that all version 6017c478bd9Sstevel@tonic-gate * definitions asked for do not exist. 6027c478bd9Sstevel@tonic-gate */ 6037c478bd9Sstevel@tonic-gate if (isp == 0) { 6047c478bd9Sstevel@tonic-gate Listnode *lnp; 6057c478bd9Sstevel@tonic-gate 6067c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&sdf->sdf_vers, lnp, sdv)) { 607*5aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 608*5aefb655Srie MSG_INTL(MSG_VER_NOEXIST), ifl->ifl_name, 609*5aefb655Srie sdv->sdv_name, sdv->sdv_ref); 6107c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 6117c478bd9Sstevel@tonic-gate } 6127c478bd9Sstevel@tonic-gate return (0); 6137c478bd9Sstevel@tonic-gate } 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate vdf = (Verdef *)isp->is_indata->d_buf; 6167c478bd9Sstevel@tonic-gate 6177c478bd9Sstevel@tonic-gate /* 6187c478bd9Sstevel@tonic-gate * Verify the version revision. We only check the first version 6197c478bd9Sstevel@tonic-gate * structure as it is assumed all other version structures in this 6207c478bd9Sstevel@tonic-gate * data section will be of the same revision. 6217c478bd9Sstevel@tonic-gate */ 6227c478bd9Sstevel@tonic-gate if (vdf->vd_version > VER_DEF_CURRENT) 623*5aefb655Srie (void) eprintf(ofl->ofl_lml, ERR_WARNING, 624*5aefb655Srie MSG_INTL(MSG_VER_HIGHER), ifl->ifl_name, vdf->vd_version, 625*5aefb655Srie VER_DEF_CURRENT); 6267c478bd9Sstevel@tonic-gate 6277c478bd9Sstevel@tonic-gate 6287c478bd9Sstevel@tonic-gate num = isp->is_shdr->sh_info; 6297c478bd9Sstevel@tonic-gate str = (char *)ifl->ifl_isdesc[isp->is_shdr->sh_link]->is_indata->d_buf; 6307c478bd9Sstevel@tonic-gate 6317c478bd9Sstevel@tonic-gate if (ifl->ifl_ehdr->e_type == ET_REL) 6327c478bd9Sstevel@tonic-gate relobj = 1; 6337c478bd9Sstevel@tonic-gate else 6347c478bd9Sstevel@tonic-gate relobj = 0; 6357c478bd9Sstevel@tonic-gate 636*5aefb655Srie DBG_CALL(Dbg_ver_def_title(ofl->ofl_lml, file)); 6377c478bd9Sstevel@tonic-gate 6387c478bd9Sstevel@tonic-gate /* 6397c478bd9Sstevel@tonic-gate * Loop through the version information setting up a version descriptor 6407c478bd9Sstevel@tonic-gate * for each version definition. 6417c478bd9Sstevel@tonic-gate */ 6427c478bd9Sstevel@tonic-gate for (_num = 1; _num <= num; _num++, 6437c478bd9Sstevel@tonic-gate vdf = (Verdef *)((uintptr_t)vdf + vdf->vd_next)) { 6447c478bd9Sstevel@tonic-gate const char *name; 6457c478bd9Sstevel@tonic-gate Ver_desc *ivdp, *ovdp = 0; 6467c478bd9Sstevel@tonic-gate Word hash; 6477c478bd9Sstevel@tonic-gate Half cnt = vdf->vd_cnt; 6487c478bd9Sstevel@tonic-gate Half ndx = vdf->vd_ndx; 6497c478bd9Sstevel@tonic-gate Verdaux *vdap = (Verdaux *)((uintptr_t)vdf + 6507c478bd9Sstevel@tonic-gate vdf->vd_aux); 6517c478bd9Sstevel@tonic-gate 6527c478bd9Sstevel@tonic-gate /* 6537c478bd9Sstevel@tonic-gate * Keep track of the largest index for use in creating a 6547c478bd9Sstevel@tonic-gate * version index array later, and create a version descriptor. 6557c478bd9Sstevel@tonic-gate */ 6567c478bd9Sstevel@tonic-gate if (ndx > ifl->ifl_vercnt) 6577c478bd9Sstevel@tonic-gate ifl->ifl_vercnt = ndx; 6587c478bd9Sstevel@tonic-gate 6597c478bd9Sstevel@tonic-gate name = (char *)(str + vdap->vda_name); 6607c478bd9Sstevel@tonic-gate /* LINTED */ 6617c478bd9Sstevel@tonic-gate hash = (Word)elf_hash(name); 662*5aefb655Srie if ((ivdp = ld_vers_find(name, hash, &ifl->ifl_verdesc)) == 0) { 663*5aefb655Srie if ((ivdp = ld_vers_desc(name, hash, 6647c478bd9Sstevel@tonic-gate &ifl->ifl_verdesc)) == (Ver_desc *)S_ERROR) 6657c478bd9Sstevel@tonic-gate return (S_ERROR); 6667c478bd9Sstevel@tonic-gate } 6677c478bd9Sstevel@tonic-gate ivdp->vd_ndx = ndx; 6687c478bd9Sstevel@tonic-gate ivdp->vd_file = ifl; 6697c478bd9Sstevel@tonic-gate ivdp->vd_flags = vdf->vd_flags; 6707c478bd9Sstevel@tonic-gate 6717c478bd9Sstevel@tonic-gate /* 6727c478bd9Sstevel@tonic-gate * If we're processing a relocatable object then this version 6737c478bd9Sstevel@tonic-gate * definition needs to be propagated to the output file. 6747c478bd9Sstevel@tonic-gate * Generate a new output file version and associated this input 6757c478bd9Sstevel@tonic-gate * version to it. During symbol processing the version index of 6767c478bd9Sstevel@tonic-gate * the symbol will be promoted from the input file to the output 6777c478bd9Sstevel@tonic-gate * files version definition. 6787c478bd9Sstevel@tonic-gate */ 6797c478bd9Sstevel@tonic-gate if (relobj) { 6807c478bd9Sstevel@tonic-gate if (!(ofl->ofl_flags & FLG_OF_RELOBJ)) 6817c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_PROCRED; 6827c478bd9Sstevel@tonic-gate 6837c478bd9Sstevel@tonic-gate if ((ivdp->vd_flags & VER_FLG_BASE) == 0) { 6847c478bd9Sstevel@tonic-gate /* 6857c478bd9Sstevel@tonic-gate * If no version descriptors have yet been set 6867c478bd9Sstevel@tonic-gate * up, initialize a base version to represent 6877c478bd9Sstevel@tonic-gate * the output file itself. This `base' version 6887c478bd9Sstevel@tonic-gate * catches any internally generated symbols 6897c478bd9Sstevel@tonic-gate * (_end, _etext, etc.) and 6907c478bd9Sstevel@tonic-gate * serves to initialize the output version 6917c478bd9Sstevel@tonic-gate * descriptor count. 6927c478bd9Sstevel@tonic-gate */ 6937c478bd9Sstevel@tonic-gate if (ofl->ofl_vercnt == 0) { 694*5aefb655Srie if (ld_vers_base(ofl) == 6957c478bd9Sstevel@tonic-gate (Ver_desc *)S_ERROR) 6967c478bd9Sstevel@tonic-gate return (S_ERROR); 6977c478bd9Sstevel@tonic-gate } 6987c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_VERDEF; 699*5aefb655Srie if ((ovdp = ld_vers_find(name, hash, 7007c478bd9Sstevel@tonic-gate &ofl->ofl_verdesc)) == 0) { 701*5aefb655Srie if ((ovdp = ld_vers_desc(name, hash, 7027c478bd9Sstevel@tonic-gate &ofl->ofl_verdesc)) == 7037c478bd9Sstevel@tonic-gate (Ver_desc *)S_ERROR) 7047c478bd9Sstevel@tonic-gate return (S_ERROR); 7057c478bd9Sstevel@tonic-gate 7067c478bd9Sstevel@tonic-gate /* LINTED */ 7077c478bd9Sstevel@tonic-gate ovdp->vd_ndx = (Half)++ofl->ofl_vercnt; 7087c478bd9Sstevel@tonic-gate ovdp->vd_file = ifl; 7097c478bd9Sstevel@tonic-gate ovdp->vd_flags = vdf->vd_flags; 7107c478bd9Sstevel@tonic-gate } 7117c478bd9Sstevel@tonic-gate } 7127c478bd9Sstevel@tonic-gate 7137c478bd9Sstevel@tonic-gate /* 7147c478bd9Sstevel@tonic-gate * Maintain the association between the input version 7157c478bd9Sstevel@tonic-gate * descriptor and the output version descriptor so that 7167c478bd9Sstevel@tonic-gate * an associated symbols will be assigned to the 7177c478bd9Sstevel@tonic-gate * correct version. 7187c478bd9Sstevel@tonic-gate */ 7197c478bd9Sstevel@tonic-gate ivdp->vd_ref = ovdp; 7207c478bd9Sstevel@tonic-gate } 7217c478bd9Sstevel@tonic-gate 7227c478bd9Sstevel@tonic-gate /* 7237c478bd9Sstevel@tonic-gate * Process any dependencies this version may have. 7247c478bd9Sstevel@tonic-gate */ 7257c478bd9Sstevel@tonic-gate vdap = (Verdaux *)((uintptr_t)vdap + vdap->vda_next); 7267c478bd9Sstevel@tonic-gate for (cnt--; cnt; cnt--, 7277c478bd9Sstevel@tonic-gate vdap = (Verdaux *)((uintptr_t)vdap + vdap->vda_next)) { 7287c478bd9Sstevel@tonic-gate Ver_desc *_ivdp; 7297c478bd9Sstevel@tonic-gate 7307c478bd9Sstevel@tonic-gate name = (char *)(str + vdap->vda_name); 7317c478bd9Sstevel@tonic-gate /* LINTED */ 7327c478bd9Sstevel@tonic-gate hash = (Word)elf_hash(name); 7337c478bd9Sstevel@tonic-gate 734*5aefb655Srie if ((_ivdp = ld_vers_find(name, hash, 7357c478bd9Sstevel@tonic-gate &ifl->ifl_verdesc)) == 0) { 736*5aefb655Srie if ((_ivdp = ld_vers_desc(name, hash, 7377c478bd9Sstevel@tonic-gate &ifl->ifl_verdesc)) == 7387c478bd9Sstevel@tonic-gate (Ver_desc *)S_ERROR) 7397c478bd9Sstevel@tonic-gate return (S_ERROR); 7407c478bd9Sstevel@tonic-gate } 7417c478bd9Sstevel@tonic-gate if (list_appendc(&ivdp->vd_deps, _ivdp) == 0) 7427c478bd9Sstevel@tonic-gate return (S_ERROR); 7437c478bd9Sstevel@tonic-gate } 744*5aefb655Srie DBG_CALL(Dbg_ver_desc_entry(ofl->ofl_lml, ivdp)); 7457c478bd9Sstevel@tonic-gate } 7467c478bd9Sstevel@tonic-gate 7477c478bd9Sstevel@tonic-gate /* 7487c478bd9Sstevel@tonic-gate * Now that we know the total number of version definitions for this 7497c478bd9Sstevel@tonic-gate * file, build an index array for fast access when processing symbols. 7507c478bd9Sstevel@tonic-gate */ 751*5aefb655Srie if ((ifl->ifl_verndx = 752*5aefb655Srie vers_index(ofl, ifl, relobj)) == (Ver_index *)S_ERROR) 7537c478bd9Sstevel@tonic-gate return (S_ERROR); 7547c478bd9Sstevel@tonic-gate 7557c478bd9Sstevel@tonic-gate if (relobj) 7567c478bd9Sstevel@tonic-gate return (1); 7577c478bd9Sstevel@tonic-gate 7587c478bd9Sstevel@tonic-gate /* 7597c478bd9Sstevel@tonic-gate * If this object has version control definitions against it then these 7607c478bd9Sstevel@tonic-gate * must be processed so as to select those version definitions to which 7617c478bd9Sstevel@tonic-gate * symbol bindings can occur. Otherwise simply mark all versions as 7627c478bd9Sstevel@tonic-gate * available. 7637c478bd9Sstevel@tonic-gate */ 764*5aefb655Srie DBG_CALL(Dbg_ver_avail_title(ofl->ofl_lml, file)); 7657c478bd9Sstevel@tonic-gate 7667c478bd9Sstevel@tonic-gate if (sdf && (sdf->sdf_flags & FLG_SDF_SELECT)) { 7677c478bd9Sstevel@tonic-gate Listnode *lnp1; 7687c478bd9Sstevel@tonic-gate 7697c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&sdf->sdf_vers, lnp1, sdv)) { 7707c478bd9Sstevel@tonic-gate Listnode *lnp2; 7717c478bd9Sstevel@tonic-gate Ver_desc *vdp; 7727c478bd9Sstevel@tonic-gate int found = 0; 7737c478bd9Sstevel@tonic-gate 7747c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&ifl->ifl_verdesc, lnp2, vdp)) { 7757c478bd9Sstevel@tonic-gate if (strcmp(sdv->sdv_name, vdp->vd_name) == 0) { 7767c478bd9Sstevel@tonic-gate found++; 7777c478bd9Sstevel@tonic-gate break; 7787c478bd9Sstevel@tonic-gate } 7797c478bd9Sstevel@tonic-gate } 7807c478bd9Sstevel@tonic-gate if (found) 781*5aefb655Srie vers_select(ofl, ifl, vdp, sdv->sdv_ref); 7827c478bd9Sstevel@tonic-gate else { 783*5aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 784*5aefb655Srie MSG_INTL(MSG_VER_NOEXIST), ifl->ifl_name, 785*5aefb655Srie sdv->sdv_name, sdv->sdv_ref); 7867c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 7877c478bd9Sstevel@tonic-gate } 7887c478bd9Sstevel@tonic-gate } 7897c478bd9Sstevel@tonic-gate } else { 7907c478bd9Sstevel@tonic-gate Ver_index *vip; 7917c478bd9Sstevel@tonic-gate int cnt; 7927c478bd9Sstevel@tonic-gate 7937c478bd9Sstevel@tonic-gate for (cnt = VER_NDX_GLOBAL; cnt <= ifl->ifl_vercnt; cnt++) { 7947c478bd9Sstevel@tonic-gate vip = &ifl->ifl_verndx[cnt]; 7957c478bd9Sstevel@tonic-gate vip->vi_flags |= FLG_VER_AVAIL; 796*5aefb655Srie DBG_CALL(Dbg_ver_avail_entry(ofl->ofl_lml, vip, 0)); 7977c478bd9Sstevel@tonic-gate } 7987c478bd9Sstevel@tonic-gate } 7997c478bd9Sstevel@tonic-gate 8007c478bd9Sstevel@tonic-gate /* 8017c478bd9Sstevel@tonic-gate * If this is an explict dependency indicate that this file is a 8027c478bd9Sstevel@tonic-gate * candidate for requiring version needed information to be recorded in 8037c478bd9Sstevel@tonic-gate * the image we're creating. 8047c478bd9Sstevel@tonic-gate */ 8057c478bd9Sstevel@tonic-gate if (ifl->ifl_flags & FLG_IF_NEEDED) 8067c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_VERNEED; 8077c478bd9Sstevel@tonic-gate 8087c478bd9Sstevel@tonic-gate return (1); 8097c478bd9Sstevel@tonic-gate } 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate /* 8127c478bd9Sstevel@tonic-gate * Process a version needed section. 8137c478bd9Sstevel@tonic-gate */ 8147c478bd9Sstevel@tonic-gate uintptr_t 815*5aefb655Srie ld_vers_need_process(Is_desc *isp, Ifl_desc *ifl, Ofl_desc *ofl) 8167c478bd9Sstevel@tonic-gate { 8177c478bd9Sstevel@tonic-gate const char *str, *file = ifl->ifl_name; 8187c478bd9Sstevel@tonic-gate Word num, _num; 8197c478bd9Sstevel@tonic-gate Verneed *vnd; 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate vnd = (Verneed *)isp->is_indata->d_buf; 8227c478bd9Sstevel@tonic-gate 8237c478bd9Sstevel@tonic-gate /* 8247c478bd9Sstevel@tonic-gate * Verify the version revision. We only check the first version 8257c478bd9Sstevel@tonic-gate * structure as it is assumed all other version structures in this 8267c478bd9Sstevel@tonic-gate * data section will be of the same revision. 8277c478bd9Sstevel@tonic-gate */ 828*5aefb655Srie if (vnd->vn_version > VER_DEF_CURRENT) { 829*5aefb655Srie (void) eprintf(ofl->ofl_lml, ERR_WARNING, 830*5aefb655Srie MSG_INTL(MSG_VER_HIGHER), ifl->ifl_name, vnd->vn_version, 831*5aefb655Srie VER_DEF_CURRENT); 832*5aefb655Srie } 8337c478bd9Sstevel@tonic-gate 8347c478bd9Sstevel@tonic-gate num = isp->is_shdr->sh_info; 8357c478bd9Sstevel@tonic-gate str = (char *)ifl->ifl_isdesc[isp->is_shdr->sh_link]->is_indata->d_buf; 8367c478bd9Sstevel@tonic-gate 837*5aefb655Srie DBG_CALL(Dbg_ver_need_title(ofl->ofl_lml, file)); 8387c478bd9Sstevel@tonic-gate 8397c478bd9Sstevel@tonic-gate /* 8407c478bd9Sstevel@tonic-gate * Loop through the version information setting up a version descriptor 8417c478bd9Sstevel@tonic-gate * for each version definition. 8427c478bd9Sstevel@tonic-gate */ 8437c478bd9Sstevel@tonic-gate for (_num = 1; _num <= num; _num++, 8447c478bd9Sstevel@tonic-gate vnd = (Verneed *)((uintptr_t)vnd + vnd->vn_next)) { 8457c478bd9Sstevel@tonic-gate Sdf_desc *sdf; 8467c478bd9Sstevel@tonic-gate Sdv_desc *sdv; 8477c478bd9Sstevel@tonic-gate const char *name; 8487c478bd9Sstevel@tonic-gate Half cnt = vnd->vn_cnt; 8497c478bd9Sstevel@tonic-gate Vernaux *vnap = (Vernaux *)((uintptr_t)vnd + 8507c478bd9Sstevel@tonic-gate vnd->vn_aux); 8517c478bd9Sstevel@tonic-gate Half _cnt; 8527c478bd9Sstevel@tonic-gate 8537c478bd9Sstevel@tonic-gate name = (char *)(str + vnd->vn_file); 8547c478bd9Sstevel@tonic-gate 8557c478bd9Sstevel@tonic-gate /* 8567c478bd9Sstevel@tonic-gate * Set up a shared object descriptor and add to it the necessary 8577c478bd9Sstevel@tonic-gate * needed versions. This information may also have been added 8587c478bd9Sstevel@tonic-gate * by a mapfile (see map_dash()). 8597c478bd9Sstevel@tonic-gate */ 8607c478bd9Sstevel@tonic-gate if ((sdf = sdf_find(name, &ofl->ofl_soneed)) == 0) { 8617c478bd9Sstevel@tonic-gate if ((sdf = sdf_add(name, &ofl->ofl_soneed)) == 8627c478bd9Sstevel@tonic-gate (Sdf_desc *)S_ERROR) 8637c478bd9Sstevel@tonic-gate return (S_ERROR); 8647c478bd9Sstevel@tonic-gate sdf->sdf_rfile = file; 8657c478bd9Sstevel@tonic-gate sdf->sdf_flags |= FLG_SDF_VERIFY; 8667c478bd9Sstevel@tonic-gate } 8677c478bd9Sstevel@tonic-gate 8687c478bd9Sstevel@tonic-gate for (_cnt = 0; cnt; _cnt++, cnt--, 8697c478bd9Sstevel@tonic-gate vnap = (Vernaux *)((uintptr_t)vnap + vnap->vna_next)) { 8707c478bd9Sstevel@tonic-gate if (!(sdv = 8717c478bd9Sstevel@tonic-gate libld_calloc(sizeof (Sdv_desc), 1))) 8727c478bd9Sstevel@tonic-gate return (S_ERROR); 8737c478bd9Sstevel@tonic-gate sdv->sdv_name = str + vnap->vna_name; 8747c478bd9Sstevel@tonic-gate sdv->sdv_ref = file; 8757c478bd9Sstevel@tonic-gate if (list_appendc(&sdf->sdf_vers, sdv) == 0) 8767c478bd9Sstevel@tonic-gate return (S_ERROR); 877*5aefb655Srie DBG_CALL(Dbg_ver_need_entry(ofl->ofl_lml, _cnt, name, 878*5aefb655Srie sdv->sdv_name)); 8797c478bd9Sstevel@tonic-gate } 8807c478bd9Sstevel@tonic-gate } 8817c478bd9Sstevel@tonic-gate 8827c478bd9Sstevel@tonic-gate return (1); 8837c478bd9Sstevel@tonic-gate } 8847c478bd9Sstevel@tonic-gate 8857c478bd9Sstevel@tonic-gate /* 8867c478bd9Sstevel@tonic-gate * If a symbol is obtained from a versioned relocatable object then the symbols 8877c478bd9Sstevel@tonic-gate * version association must be promoted to the version definition as it will be 8887c478bd9Sstevel@tonic-gate * represented in the output file. 8897c478bd9Sstevel@tonic-gate */ 8907c478bd9Sstevel@tonic-gate void 891*5aefb655Srie ld_vers_promote(Sym_desc *sdp, Word ndx, Ifl_desc *ifl, Ofl_desc *ofl) 8927c478bd9Sstevel@tonic-gate { 8937c478bd9Sstevel@tonic-gate Half vndx; 8947c478bd9Sstevel@tonic-gate 8957c478bd9Sstevel@tonic-gate /* 8967c478bd9Sstevel@tonic-gate * A version symbol index of 0 implies the symbol is local. A value of 8977c478bd9Sstevel@tonic-gate * VER_NDX_GLOBAL implies the symbol is global but has not been 8987c478bd9Sstevel@tonic-gate * assigned to a specfic version definition. 8997c478bd9Sstevel@tonic-gate */ 9007c478bd9Sstevel@tonic-gate vndx = ifl->ifl_versym[ndx]; 9017c478bd9Sstevel@tonic-gate if (vndx == 0) { 9027c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_REDUCED; 9037c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_LOCL; 9047c478bd9Sstevel@tonic-gate return; 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate if (vndx == VER_NDX_ELIMINATE) { 9087c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_REDUCED; 9097c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= (FLG_SY1_LOCL | FLG_SY1_ELIM); 9107c478bd9Sstevel@tonic-gate return; 9117c478bd9Sstevel@tonic-gate } 9127c478bd9Sstevel@tonic-gate 9137c478bd9Sstevel@tonic-gate if (vndx == VER_NDX_GLOBAL) { 9147c478bd9Sstevel@tonic-gate if (!(sdp->sd_flags1 & FLG_SY1_LOCL)) { 9157c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_GLOB; 9167c478bd9Sstevel@tonic-gate sdp->sd_aux->sa_overndx = VER_NDX_GLOBAL; 9177c478bd9Sstevel@tonic-gate } 9187c478bd9Sstevel@tonic-gate return; 9197c478bd9Sstevel@tonic-gate } 9207c478bd9Sstevel@tonic-gate 9217c478bd9Sstevel@tonic-gate /* 9227c478bd9Sstevel@tonic-gate * Any other version index requires association to the appropriate 9237c478bd9Sstevel@tonic-gate * version definition. 9247c478bd9Sstevel@tonic-gate */ 9257c478bd9Sstevel@tonic-gate if ((ifl->ifl_verndx == 0) || (vndx > ifl->ifl_vercnt)) { 926*5aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_VER_INVALNDX), 927*5aefb655Srie sdp->sd_name, ifl->ifl_name, vndx); 9287c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 9297c478bd9Sstevel@tonic-gate return; 9307c478bd9Sstevel@tonic-gate } 9317c478bd9Sstevel@tonic-gate 9327c478bd9Sstevel@tonic-gate if (!(sdp->sd_flags1 & FLG_SY1_LOCL)) 9337c478bd9Sstevel@tonic-gate sdp->sd_flags1 |= FLG_SY1_GLOB; 9347c478bd9Sstevel@tonic-gate 9357c478bd9Sstevel@tonic-gate /* 9367c478bd9Sstevel@tonic-gate * Promote the symbols version index to the appropriate output version 9377c478bd9Sstevel@tonic-gate * definition. 9387c478bd9Sstevel@tonic-gate */ 9397c478bd9Sstevel@tonic-gate if (!(sdp->sd_flags & FLG_SY_VERSPROM)) { 9407c478bd9Sstevel@tonic-gate Ver_index *vip; 9417c478bd9Sstevel@tonic-gate 9427c478bd9Sstevel@tonic-gate vip = &ifl->ifl_verndx[vndx]; 9437c478bd9Sstevel@tonic-gate sdp->sd_aux->sa_overndx = vip->vi_desc->vd_ref->vd_ndx; 9447c478bd9Sstevel@tonic-gate sdp->sd_flags |= FLG_SY_VERSPROM; 9457c478bd9Sstevel@tonic-gate } 9467c478bd9Sstevel@tonic-gate } 9477c478bd9Sstevel@tonic-gate 9487c478bd9Sstevel@tonic-gate /* 9497c478bd9Sstevel@tonic-gate * If any versioning is called for make sure an initial version descriptor is 9507c478bd9Sstevel@tonic-gate * assigned to represent the file itself. Known as the base version. 9517c478bd9Sstevel@tonic-gate */ 9527c478bd9Sstevel@tonic-gate Ver_desc * 953*5aefb655Srie ld_vers_base(Ofl_desc *ofl) 9547c478bd9Sstevel@tonic-gate { 9557c478bd9Sstevel@tonic-gate Ver_desc *vdp; 9567c478bd9Sstevel@tonic-gate const char *name; 9577c478bd9Sstevel@tonic-gate 9587c478bd9Sstevel@tonic-gate /* 9597c478bd9Sstevel@tonic-gate * Determine the filename to associate to the version descriptor. This 9607c478bd9Sstevel@tonic-gate * is either the SONAME (if one has been supplied) or the basename of 9617c478bd9Sstevel@tonic-gate * the output file. 9627c478bd9Sstevel@tonic-gate */ 9637c478bd9Sstevel@tonic-gate if ((name = ofl->ofl_soname) == 0) { 9647c478bd9Sstevel@tonic-gate const char *str = ofl->ofl_name; 9657c478bd9Sstevel@tonic-gate 9667c478bd9Sstevel@tonic-gate while (*str != '\0') { 9677c478bd9Sstevel@tonic-gate if (*str++ == '/') 9687c478bd9Sstevel@tonic-gate name = str; 9697c478bd9Sstevel@tonic-gate } 9707c478bd9Sstevel@tonic-gate if (name == 0) 9717c478bd9Sstevel@tonic-gate name = ofl->ofl_name; 9727c478bd9Sstevel@tonic-gate } 9737c478bd9Sstevel@tonic-gate 9747c478bd9Sstevel@tonic-gate /* 9757c478bd9Sstevel@tonic-gate * Generate the version descriptor. 9767c478bd9Sstevel@tonic-gate */ 9777c478bd9Sstevel@tonic-gate /* LINTED */ 978*5aefb655Srie if ((vdp = ld_vers_desc(name, (Word)elf_hash(name), 979*5aefb655Srie &ofl->ofl_verdesc)) == (Ver_desc *)S_ERROR) 9807c478bd9Sstevel@tonic-gate return ((Ver_desc *)S_ERROR); 9817c478bd9Sstevel@tonic-gate 9827c478bd9Sstevel@tonic-gate /* 9837c478bd9Sstevel@tonic-gate * Assign the base index to this version and initialize the output file 9847c478bd9Sstevel@tonic-gate * descriptor with the number of version descriptors presently in use. 9857c478bd9Sstevel@tonic-gate */ 9867c478bd9Sstevel@tonic-gate vdp->vd_ndx = ofl->ofl_vercnt = VER_NDX_GLOBAL; 9877c478bd9Sstevel@tonic-gate vdp->vd_flags |= VER_FLG_BASE; 9887c478bd9Sstevel@tonic-gate 9897c478bd9Sstevel@tonic-gate return (vdp); 9907c478bd9Sstevel@tonic-gate } 9917c478bd9Sstevel@tonic-gate 9927c478bd9Sstevel@tonic-gate /* 9937c478bd9Sstevel@tonic-gate * Now that all input shared objects have been processed, verify that all 9947c478bd9Sstevel@tonic-gate * version requirements have been met. Any version control requirements will 9957c478bd9Sstevel@tonic-gate * have been specified by the user (and placed on the ofl_oscntl list) and are 9967c478bd9Sstevel@tonic-gate * verified at the time the object was processed (see ver_def_process()). 9977c478bd9Sstevel@tonic-gate * Here we process all version requirements established from shared objects 9987c478bd9Sstevel@tonic-gate * themselves (ie,. NEEDED dependencies). 9997c478bd9Sstevel@tonic-gate */ 10007c478bd9Sstevel@tonic-gate int 1001*5aefb655Srie ld_vers_verify(Ofl_desc *ofl) 10027c478bd9Sstevel@tonic-gate { 10037c478bd9Sstevel@tonic-gate Listnode *lnp1; 10047c478bd9Sstevel@tonic-gate Sdf_desc *sdf; 10057c478bd9Sstevel@tonic-gate char *nv; 10067c478bd9Sstevel@tonic-gate 10077c478bd9Sstevel@tonic-gate /* 10087c478bd9Sstevel@tonic-gate * As with the runtime environment, disable all version verification if 10097c478bd9Sstevel@tonic-gate * requested. 10107c478bd9Sstevel@tonic-gate */ 10117c478bd9Sstevel@tonic-gate #if defined(_ELF64) 10127c478bd9Sstevel@tonic-gate if ((nv = getenv(MSG_ORIG(MSG_LD_NOVERSION_64))) == NULL) 10137c478bd9Sstevel@tonic-gate #else 10147c478bd9Sstevel@tonic-gate if ((nv = getenv(MSG_ORIG(MSG_LD_NOVERSION_32))) == NULL) 10157c478bd9Sstevel@tonic-gate #endif 10167c478bd9Sstevel@tonic-gate nv = getenv(MSG_ORIG(MSG_LD_NOVERSION)); 10177c478bd9Sstevel@tonic-gate 10187c478bd9Sstevel@tonic-gate if (nv && (*nv != '\0')) 10197c478bd9Sstevel@tonic-gate return (1); 10207c478bd9Sstevel@tonic-gate 10217c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&ofl->ofl_soneed, lnp1, sdf)) { 10227c478bd9Sstevel@tonic-gate Listnode *lnp2; 10237c478bd9Sstevel@tonic-gate Sdv_desc *sdv; 10247c478bd9Sstevel@tonic-gate Ifl_desc *ifl = sdf->sdf_file; 10257c478bd9Sstevel@tonic-gate 10267c478bd9Sstevel@tonic-gate if (!(sdf->sdf_flags & FLG_SDF_VERIFY)) 10277c478bd9Sstevel@tonic-gate continue; 10287c478bd9Sstevel@tonic-gate 10297c478bd9Sstevel@tonic-gate /* 10307c478bd9Sstevel@tonic-gate * If this file contains no version definitions then ignore 10317c478bd9Sstevel@tonic-gate * any versioning verification. This is the same model as 10327c478bd9Sstevel@tonic-gate * carried out by ld.so.1 and is intended to allow backward 10337c478bd9Sstevel@tonic-gate * compatibility should a shared object with a version 10347c478bd9Sstevel@tonic-gate * requirment be returned to an older system on which a 10357c478bd9Sstevel@tonic-gate * non-versioned shared object exists. 10367c478bd9Sstevel@tonic-gate */ 10377c478bd9Sstevel@tonic-gate if ((ifl == 0) || (ifl->ifl_verdesc.head == 0)) 10387c478bd9Sstevel@tonic-gate continue; 10397c478bd9Sstevel@tonic-gate 10407c478bd9Sstevel@tonic-gate /* 10417c478bd9Sstevel@tonic-gate * If individual versions were specified for this file make 10427c478bd9Sstevel@tonic-gate * sure that they actually exist in the appropriate file, and 10437c478bd9Sstevel@tonic-gate * that they are available for binding. 10447c478bd9Sstevel@tonic-gate */ 10457c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&sdf->sdf_vers, lnp2, sdv)) { 10467c478bd9Sstevel@tonic-gate Listnode *lnp3; 10477c478bd9Sstevel@tonic-gate Ver_desc *vdp; 10487c478bd9Sstevel@tonic-gate int found = 0; 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate for (LIST_TRAVERSE(&ifl->ifl_verdesc, lnp3, vdp)) { 10517c478bd9Sstevel@tonic-gate if (strcmp(sdv->sdv_name, vdp->vd_name) == 0) { 10527c478bd9Sstevel@tonic-gate found++; 10537c478bd9Sstevel@tonic-gate break; 10547c478bd9Sstevel@tonic-gate } 10557c478bd9Sstevel@tonic-gate } 10567c478bd9Sstevel@tonic-gate if (found) { 10577c478bd9Sstevel@tonic-gate Ver_index *vip; 10587c478bd9Sstevel@tonic-gate 10597c478bd9Sstevel@tonic-gate vip = &ifl->ifl_verndx[vdp->vd_ndx]; 10607c478bd9Sstevel@tonic-gate if (!(vip->vi_flags & FLG_VER_AVAIL)) { 1061*5aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 10627c478bd9Sstevel@tonic-gate MSG_INTL(MSG_VER_UNAVAIL), 10637c478bd9Sstevel@tonic-gate ifl->ifl_name, sdv->sdv_name, 10647c478bd9Sstevel@tonic-gate sdv->sdv_ref); 10657c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 10667c478bd9Sstevel@tonic-gate } 10677c478bd9Sstevel@tonic-gate } else { 1068*5aefb655Srie eprintf(ofl->ofl_lml, ERR_FATAL, 1069*5aefb655Srie MSG_INTL(MSG_VER_NOEXIST), ifl->ifl_name, 1070*5aefb655Srie sdv->sdv_name, sdv->sdv_ref); 10717c478bd9Sstevel@tonic-gate ofl->ofl_flags |= FLG_OF_FATAL; 10727c478bd9Sstevel@tonic-gate } 10737c478bd9Sstevel@tonic-gate } 10747c478bd9Sstevel@tonic-gate } 10757c478bd9Sstevel@tonic-gate return (1); 10767c478bd9Sstevel@tonic-gate } 1077