1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1988 AT&T
24 * All Rights Reserved
25 *
26 *
27 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
28 */
29
30 /*
31 * Symbol table management routines
32 */
33
34 #define ELF_TARGET_AMD64
35
36 #include <stdio.h>
37 #include <string.h>
38 #include <debug.h>
39 #include "msg.h"
40 #include "_libld.h"
41
42 /*
43 * AVL tree comparator function:
44 *
45 * The primary key is the symbol name hash with a secondary key of the symbol
46 * name itself.
47 */
48 int
49 ld_sym_avl_comp(const void *elem1, const void *elem2)
50 {
51 Sym_avlnode *sav1 = (Sym_avlnode *)elem1;
52 Sym_avlnode *sav2 = (Sym_avlnode *)elem2;
53 int res;
54
55 res = sav1->sav_hash - sav2->sav_hash;
56
57 if (res < 0)
58 return (-1);
59 if (res > 0)
60 return (1);
61
62 /*
63 * Hash is equal - now compare name
64 */
65 res = strcmp(sav1->sav_name, sav2->sav_name);
66 if (res == 0)
67 return (0);
68 if (res > 0)
69 return (1);
70 return (-1);
71 }
72
73 /*
74 * Focal point for verifying symbol names.
75 */
76 inline static const char *
77 string(Ofl_desc *ofl, Ifl_desc *ifl, Sym *sym, const char *strs, size_t strsize,
78 int symndx, Word shndx, Word symsecndx, const char *symsecname,
79 const char *strsecname, sd_flag_t *flags)
80 {
81 Word name = sym->st_name;
82
83 if (name) {
84 if ((ifl->ifl_flags & FLG_IF_HSTRTAB) == 0) {
85 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_NOSTRTABLE),
86 ifl->ifl_name, EC_WORD(symsecndx), symsecname,
87 symndx, EC_XWORD(name));
88 return (NULL);
89 }
90 if (name >= (Word)strsize) {
91 ld_eprintf(ofl, ERR_FATAL,
92 MSG_INTL(MSG_FIL_EXCSTRTABLE), ifl->ifl_name,
93 EC_WORD(symsecndx), symsecname, symndx,
94 EC_XWORD(name), strsecname, EC_XWORD(strsize));
95 return (NULL);
96 }
97 }
98
99 /*
100 * Determine if we're dealing with a register and if so validate it.
101 * If it's a scratch register, a fabricated name will be returned.
102 */
103 if (ld_targ.t_ms.ms_is_regsym != NULL) {
104 const char *regname = (*ld_targ.t_ms.ms_is_regsym)(ofl, ifl,
105 sym, strs, symndx, shndx, symsecname, flags);
106
107 if (regname == (const char *)S_ERROR) {
108 return (NULL);
109 }
110 if (regname)
111 return (regname);
112 }
113
114 /*
115 * If this isn't a register, but we have a global symbol with a null
116 * name, we're not going to be able to hash this, search for it, or
117 * do anything interesting. However, we've been accepting a symbol of
118 * this kind for ages now, so give the user a warning (rather than a
119 * fatal error), just in case this instance exists somewhere in the
120 * world and hasn't, as yet, been a problem.
121 */
122 if ((name == 0) && (ELF_ST_BIND(sym->st_info) != STB_LOCAL)) {
123 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_FIL_NONAMESYM),
124 ifl->ifl_name, EC_WORD(symsecndx), symsecname, symndx,
125 EC_XWORD(name));
126 }
127 return (strs + name);
128 }
129
130 /*
131 * For producing symbol names strings to use in error messages.
132 * If the symbol has a non-null name, then the string returned by
133 * this function is the output from demangle(), surrounded by
134 * single quotes. For null names, a descriptive string giving
135 * the symbol section and index is generated.
136 *
137 * This function uses an internal static buffer to hold the resulting
138 * string. The value returned is usable by the caller until the next
139 * call, at which point it is overwritten.
140 */
141 static const char *
142 demangle_symname(const char *name, const char *symtab_name, Word symndx)
143 {
144 #define INIT_BUFSIZE 256
145
146 static char *buf;
147 static size_t bufsize = 0;
148 size_t len;
149 int use_name;
150
151 use_name = (name != NULL) && (*name != '\0');
152
153 if (use_name) {
154 name = demangle(name);
155 len = strlen(name) + 2; /* Include room for quotes */
156 } else {
157 name = MSG_ORIG(MSG_STR_EMPTY);
158 len = strlen(symtab_name) + 2 + CONV_INV_BUFSIZE;
159 }
160 len++; /* Null termination */
161
162 /* If our buffer is too small, double it until it is big enough */
163 if (len > bufsize) {
164 size_t new_bufsize = bufsize;
165 char *new_buf;
166
167 if (new_bufsize == 0)
168 new_bufsize = INIT_BUFSIZE;
169 while (len > new_bufsize)
170 new_bufsize *= 2;
171 if ((new_buf = libld_malloc(new_bufsize)) == NULL)
172 return (name);
173 buf = new_buf;
174 bufsize = new_bufsize;
175 }
176
177 if (use_name) {
178 (void) snprintf(buf, bufsize, MSG_ORIG(MSG_FMT_SYMNAM), name);
179 } else {
180 (void) snprintf(buf, bufsize, MSG_ORIG(MSG_FMT_NULLSYMNAM),
181 symtab_name, EC_WORD(symndx));
182 }
183
184 return (buf);
185
186 #undef INIT_BUFSIZE
187 }
188
189 /*
190 * Shared objects can be built that define specific symbols that can not be
191 * directly bound to. These objects have a syminfo section (and an associated
192 * DF_1_NODIRECT dynamic flags entry). Scan this table looking for symbols
193 * that can't be bound to directly, and if this files symbol is presently
194 * referenced, mark it so that we don't directly bind to it.
195 */
196 uintptr_t
197 ld_sym_nodirect(Is_desc *isp, Ifl_desc *ifl, Ofl_desc *ofl)
198 {
199 Shdr *sifshdr, *symshdr;
200 Syminfo *sifdata;
201 Sym *symdata;
202 char *strdata;
203 ulong_t cnt, _cnt;
204
205 /*
206 * Get the syminfo data, and determine the number of entries.
207 */
208 sifshdr = isp->is_shdr;
209 sifdata = (Syminfo *)isp->is_indata->d_buf;
210 cnt = sifshdr->sh_size / sifshdr->sh_entsize;
211
212 /*
213 * Get the associated symbol table.
214 */
215 if ((sifshdr->sh_link == 0) || (sifshdr->sh_link >= ifl->ifl_shnum)) {
216 /*
217 * Broken input file
218 */
219 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_FIL_INVSHINFO),
220 ifl->ifl_name, isp->is_name, EC_XWORD(sifshdr->sh_link));
221 return (0);
222 }
223 symshdr = ifl->ifl_isdesc[sifshdr->sh_link]->is_shdr;
224 symdata = ifl->ifl_isdesc[sifshdr->sh_link]->is_indata->d_buf;
225
226 /*
227 * Get the string table associated with the symbol table.
228 */
229 strdata = ifl->ifl_isdesc[symshdr->sh_link]->is_indata->d_buf;
230
231 /*
232 * Traverse the syminfo data for symbols that can't be directly
233 * bound to.
234 */
235 for (_cnt = 1, sifdata++; _cnt < cnt; _cnt++, sifdata++) {
236 Sym *sym;
237 char *str;
238 Sym_desc *sdp;
239
240 if ((sifdata->si_flags & SYMINFO_FLG_NOEXTDIRECT) == 0)
241 continue;
242
243 sym = (Sym *)(symdata + _cnt);
244 str = (char *)(strdata + sym->st_name);
245
246 if ((sdp = ld_sym_find(str, SYM_NOHASH, NULL, ofl)) != NULL) {
247 if (ifl != sdp->sd_file)
248 continue;
249
250 sdp->sd_flags &= ~FLG_SY_DIR;
251 sdp->sd_flags |= FLG_SY_NDIR;
252 }
253 }
254 return (0);
255 }
256
257 /*
258 * If, during symbol processing, it is necessary to update a local symbols
259 * contents before we have generated the symbol tables in the output image,
260 * create a new symbol structure and copy the original symbol contents. While
261 * we are processing the input files, their local symbols are part of the
262 * read-only mapped image. Commonly, these symbols are copied to the new output
263 * file image and then updated to reflect their new address and any change in
264 * attributes. However, sometimes during relocation counting, it is necessary
265 * to adjust the symbols information. This routine provides for the generation
266 * of a new symbol image so that this update can be performed.
267 * All global symbols are copied to an internal symbol table to improve locality
268 * of reference and hence performance, and thus this copying is not necessary.
269 */
270 uintptr_t
271 ld_sym_copy(Sym_desc *sdp)
272 {
273 Sym *nsym;
274
275 if (sdp->sd_flags & FLG_SY_CLEAN) {
276 if ((nsym = libld_malloc(sizeof (Sym))) == NULL)
277 return (S_ERROR);
278 *nsym = *(sdp->sd_sym);
279 sdp->sd_sym = nsym;
280 sdp->sd_flags &= ~FLG_SY_CLEAN;
281 }
282 return (1);
283 }
284
285 /*
286 * Finds a given name in the link editors internal symbol table. If no
287 * hash value is specified it is calculated. A pointer to the located
288 * Sym_desc entry is returned, or NULL if the symbol is not found.
289 */
290 Sym_desc *
291 ld_sym_find(const char *name, Word hash, avl_index_t *where, Ofl_desc *ofl)
292 {
293 Sym_avlnode qsav, *sav;
294
295 if (hash == SYM_NOHASH)
296 /* LINTED */
297 hash = (Word)elf_hash((const char *)name);
298 qsav.sav_hash = hash;
299 qsav.sav_name = name;
300
301 /*
302 * Perform search for symbol in AVL tree. Note that the 'where' field
303 * is passed in from the caller. If a 'where' is present, it can be
304 * used in subsequent 'ld_sym_enter()' calls if required.
305 */
306 sav = avl_find(&ofl->ofl_symavl, &qsav, where);
307
308 /*
309 * If symbol was not found in the avl tree, return null to show that.
310 */
311 if (sav == NULL)
312 return (NULL);
313
314 /*
315 * Return symbol found.
316 */
317 return (sav->sav_sdp);
318 }
319
320 /*
321 * Enter a new symbol into the link editors internal symbol table.
322 * If the symbol is from an input file, information regarding the input file
323 * and input section is also recorded. Otherwise (file == NULL) the symbol
324 * has been internally generated (ie. _etext, _edata, etc.).
325 */
326 Sym_desc *
327 ld_sym_enter(const char *name, Sym *osym, Word hash, Ifl_desc *ifl,
328 Ofl_desc *ofl, Word ndx, Word shndx, sd_flag_t sdflags, avl_index_t *where)
329 {
330 Sym_desc *sdp;
331 Sym_aux *sap;
332 Sym_avlnode *savl;
333 char *_name;
334 Sym *nsym;
335 Half etype;
336 uchar_t vis;
337 avl_index_t _where;
338
339 /*
340 * Establish the file type.
341 */
342 if (ifl)
343 etype = ifl->ifl_ehdr->e_type;
344 else
345 etype = ET_NONE;
346
347 ofl->ofl_entercnt++;
348
349 /*
350 * Allocate a Sym Descriptor, Auxiliary Descriptor, and a Sym AVLNode -
351 * contiguously.
352 */
353 if ((savl = libld_calloc(S_DROUND(sizeof (Sym_avlnode)) +
354 S_DROUND(sizeof (Sym_desc)) +
355 S_DROUND(sizeof (Sym_aux)), 1)) == NULL)
356 return ((Sym_desc *)S_ERROR);
357 sdp = (Sym_desc *)((uintptr_t)savl +
358 S_DROUND(sizeof (Sym_avlnode)));
359 sap = (Sym_aux *)((uintptr_t)sdp +
360 S_DROUND(sizeof (Sym_desc)));
361
362 savl->sav_sdp = sdp;
363 sdp->sd_file = ifl;
364 sdp->sd_aux = sap;
365 savl->sav_hash = sap->sa_hash = hash;
366
367 /*
368 * Copy the symbol table entry from the input file into the internal
369 * entry and have the symbol descriptor use it.
370 */
371 sdp->sd_sym = nsym = &sap->sa_sym;
372 *nsym = *osym;
373 sdp->sd_shndx = shndx;
374 sdp->sd_flags |= sdflags;
375
376 if ((_name = libld_malloc(strlen(name) + 1)) == NULL)
377 return ((Sym_desc *)S_ERROR);
378 savl->sav_name = sdp->sd_name = (const char *)strcpy(_name, name);
379
380 /*
381 * Enter Symbol in AVL tree.
382 */
383 if (where == 0) {
384 /* LINTED */
385 Sym_avlnode *_savl;
386 /*
387 * If a previous ld_sym_find() hasn't initialized 'where' do it
388 * now.
389 */
390 where = &_where;
391 _savl = avl_find(&ofl->ofl_symavl, savl, where);
392 assert(_savl == NULL);
393 }
394 avl_insert(&ofl->ofl_symavl, savl, *where);
395
396 /*
397 * Record the section index. This is possible because the
398 * `ifl_isdesc' table is filled before we start symbol processing.
399 */
400 if ((sdflags & FLG_SY_SPECSEC) || (nsym->st_shndx == SHN_UNDEF))
401 sdp->sd_isc = NULL;
402 else {
403 sdp->sd_isc = ifl->ifl_isdesc[shndx];
404
405 /*
406 * If this symbol is from a relocatable object, make sure that
407 * it is still associated with a section. For example, an
408 * unknown section type (SHT_NULL) would have been rejected on
409 * input with a warning. Here, we make the use of the symbol
410 * fatal. A symbol descriptor is still returned, so that the
411 * caller can continue processing all symbols, and hence flush
412 * out as many error conditions as possible.
413 */
414 if ((etype == ET_REL) && (sdp->sd_isc == NULL)) {
415 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_INVSEC),
416 name, ifl->ifl_name, EC_XWORD(shndx));
417 return (sdp);
418 }
419 }
420
421 /*
422 * Mark any COMMON symbols as 'tentative'.
423 */
424 if (sdflags & FLG_SY_SPECSEC) {
425 if (nsym->st_shndx == SHN_COMMON)
426 sdp->sd_flags |= FLG_SY_TENTSYM;
427 #if defined(_ELF64)
428 else if ((ld_targ.t_m.m_mach == EM_AMD64) &&
429 (nsym->st_shndx == SHN_X86_64_LCOMMON))
430 sdp->sd_flags |= FLG_SY_TENTSYM;
431 #endif
432 }
433
434 /*
435 * Establish the symbols visibility and reference.
436 */
437 vis = ELF_ST_VISIBILITY(nsym->st_other);
438
439 if ((etype == ET_NONE) || (etype == ET_REL)) {
440 switch (vis) {
441 case STV_DEFAULT:
442 sdp->sd_flags |= FLG_SY_DEFAULT;
443 break;
444 case STV_INTERNAL:
445 case STV_HIDDEN:
446 sdp->sd_flags |= FLG_SY_HIDDEN;
447 break;
448 case STV_PROTECTED:
449 sdp->sd_flags |= FLG_SY_PROTECT;
450 break;
451 case STV_EXPORTED:
452 sdp->sd_flags |= FLG_SY_EXPORT;
453 break;
454 case STV_SINGLETON:
455 sdp->sd_flags |= (FLG_SY_SINGLE | FLG_SY_NDIR);
456 ofl->ofl_flags1 |= (FLG_OF1_NDIRECT | FLG_OF1_NGLBDIR);
457 break;
458 case STV_ELIMINATE:
459 sdp->sd_flags |= (FLG_SY_HIDDEN | FLG_SY_ELIM);
460 break;
461 default:
462 assert(vis <= STV_ELIMINATE);
463 }
464
465 sdp->sd_ref = REF_REL_NEED;
466
467 /*
468 * Under -Bnodirect, all exported interfaces that have not
469 * explicitly been defined protected or directly bound to, are
470 * tagged to prevent direct binding.
471 */
472 if ((ofl->ofl_flags1 & FLG_OF1_ALNODIR) &&
473 ((sdp->sd_flags & (FLG_SY_PROTECT | FLG_SY_DIR)) == 0) &&
474 (nsym->st_shndx != SHN_UNDEF)) {
475 sdp->sd_flags |= FLG_SY_NDIR;
476 }
477 } else {
478 sdp->sd_ref = REF_DYN_SEEN;
479
480 /*
481 * If this is a protected symbol, remember this. Note, this
482 * state is different from the FLG_SY_PROTECT used to establish
483 * a symbol definitions visibility. This state is used to warn
484 * against possible copy relocations against this referenced
485 * symbol.
486 */
487 if (vis == STV_PROTECTED)
488 sdp->sd_flags |= FLG_SY_PROT;
489
490 /*
491 * If this is a SINGLETON definition, then indicate the symbol
492 * can not be directly bound to, and retain the visibility.
493 * This visibility will be inherited by any references made to
494 * this symbol.
495 */
496 if ((vis == STV_SINGLETON) && (nsym->st_shndx != SHN_UNDEF))
497 sdp->sd_flags |= (FLG_SY_SINGLE | FLG_SY_NDIR);
498
499 /*
500 * If the new symbol is from a shared library and is associated
501 * with a SHT_NOBITS section then this symbol originated from a
502 * tentative symbol.
503 */
504 if (sdp->sd_isc &&
505 (sdp->sd_isc->is_shdr->sh_type == SHT_NOBITS))
506 sdp->sd_flags |= FLG_SY_TENTSYM;
507 }
508
509 /*
510 * Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF so as to
511 * simplify future processing.
512 */
513 if (nsym->st_shndx == SHN_SUNW_IGNORE) {
514 sdp->sd_shndx = shndx = SHN_UNDEF;
515 sdp->sd_flags |= (FLG_SY_REDUCED |
516 FLG_SY_HIDDEN | FLG_SY_IGNORE | FLG_SY_ELIM);
517 }
518
519 /*
520 * If this is an undefined, or common symbol from a relocatable object
521 * determine whether it is a global or weak reference (see build_osym(),
522 * where REF_DYN_NEED definitions are returned back to undefines).
523 */
524 if ((etype == ET_REL) &&
525 (ELF_ST_BIND(nsym->st_info) == STB_GLOBAL) &&
526 ((nsym->st_shndx == SHN_UNDEF) || ((sdflags & FLG_SY_SPECSEC) &&
527 #if defined(_ELF64)
528 ((nsym->st_shndx == SHN_COMMON) ||
529 ((ld_targ.t_m.m_mach == EM_AMD64) &&
530 (nsym->st_shndx == SHN_X86_64_LCOMMON))))))
531 #else
532 /* BEGIN CSTYLED */
533 (nsym->st_shndx == SHN_COMMON))))
534 /* END CSTYLED */
535 #endif
536 sdp->sd_flags |= FLG_SY_GLOBREF;
537
538 /*
539 * Record the input filename on the referenced or defined files list
540 * for possible later diagnostics. The `sa_rfile' pointer contains the
541 * name of the file that first referenced this symbol and is used to
542 * generate undefined symbol diagnostics (refer to sym_undef_entry()).
543 * Note that this entry can be overridden if a reference from a
544 * relocatable object is found after a reference from a shared object
545 * (refer to sym_override()).
546 * The `sa_dfiles' list is used to maintain the list of files that
547 * define the same symbol. This list can be used for two reasons:
548 *
549 * - To save the first definition of a symbol that is not available
550 * for this link-edit.
551 *
552 * - To save all definitions of a symbol when the -m option is in
553 * effect. This is optional as it is used to list multiple
554 * (interposed) definitions of a symbol (refer to ldmap_out()),
555 * and can be quite expensive.
556 */
557 if (nsym->st_shndx == SHN_UNDEF) {
558 sap->sa_rfile = ifl->ifl_name;
559 } else {
560 if (sdp->sd_ref == REF_DYN_SEEN) {
561 /*
562 * A symbol is determined to be unavailable if it
563 * belongs to a version of a shared object that this
564 * user does not wish to use, or if it belongs to an
565 * implicit shared object.
566 */
567 if (ifl->ifl_vercnt) {
568 Ver_index *vip;
569 Half vndx = ifl->ifl_versym[ndx];
570
571 sap->sa_dverndx = vndx;
572 vip = &ifl->ifl_verndx[vndx];
573 if (!(vip->vi_flags & FLG_VER_AVAIL)) {
574 sdp->sd_flags |= FLG_SY_NOTAVAIL;
575 sap->sa_vfile = ifl->ifl_name;
576 }
577 }
578 if (!(ifl->ifl_flags & FLG_IF_NEEDED))
579 sdp->sd_flags |= FLG_SY_NOTAVAIL;
580
581 } else if (etype == ET_REL) {
582 /*
583 * If this symbol has been obtained from a versioned
584 * input relocatable object then the new symbol must be
585 * promoted to the versioning of the output file.
586 */
587 if (ifl->ifl_versym)
588 ld_vers_promote(sdp, ndx, ifl, ofl);
589 }
590
591 if ((ofl->ofl_flags & FLG_OF_GENMAP) &&
592 ((sdflags & FLG_SY_SPECSEC) == 0))
593 if (aplist_append(&sap->sa_dfiles, ifl->ifl_name,
594 AL_CNT_SDP_DFILES) == NULL)
595 return ((Sym_desc *)S_ERROR);
596 }
597
598 /*
599 * Provided we're not processing a mapfile, diagnose the entered symbol.
600 * Mapfile processing requires the symbol to be updated with additional
601 * information, therefore the diagnosing of the symbol is deferred until
602 * later (see Dbg_map_symbol()).
603 */
604 if ((ifl == NULL) || ((ifl->ifl_flags & FLG_IF_MAPFILE) == 0))
605 DBG_CALL(Dbg_syms_entered(ofl, nsym, sdp));
606
607 return (sdp);
608 }
609
610 /*
611 * Add a special symbol to the symbol table. Takes special symbol name with
612 * and without underscores. This routine is called, after all other symbol
613 * resolution has completed, to generate a reserved absolute symbol (the
614 * underscore version). Special symbols are updated with the appropriate
615 * values in update_osym(). If the user has already defined this symbol
616 * issue a warning and leave the symbol as is. If the non-underscore symbol
617 * is referenced then turn it into a weak alias of the underscored symbol.
618 *
619 * The bits in sdflags_u are OR'd into the flags field of the symbol for the
620 * underscored symbol.
621 *
622 * If this is a global symbol, and it hasn't explicitly been defined as being
623 * directly bound to, indicate that it can't be directly bound to.
624 * Historically, most special symbols only have meaning to the object in which
625 * they exist, however, they've always been global. To ensure compatibility
626 * with any unexpected use presently in effect, ensure these symbols don't get
627 * directly bound to. Note, that establishing this state here isn't sufficient
628 * to create a syminfo table, only if a syminfo table is being created by some
629 * other symbol directives will the nodirect binding be recorded. This ensures
630 * we don't create syminfo sections for all objects we create, as this might add
631 * unnecessary bloat to users who haven't explicitly requested extra symbol
632 * information.
633 */
634 static uintptr_t
635 sym_add_spec(const char *name, const char *uname, Word sdaux_id,
636 sd_flag_t sdflags_u, sd_flag_t sdflags, Ofl_desc *ofl)
637 {
638 Sym_desc *sdp;
639 Sym_desc *usdp;
640 Sym *sym;
641 Word hash;
642 avl_index_t where;
643
644 /* LINTED */
645 hash = (Word)elf_hash(uname);
646 if (usdp = ld_sym_find(uname, hash, &where, ofl)) {
647 /*
648 * If the underscore symbol exists and is undefined, or was
649 * defined in a shared library, convert it to a local symbol.
650 * Otherwise leave it as is and warn the user.
651 */
652 if ((usdp->sd_shndx == SHN_UNDEF) ||
653 (usdp->sd_ref != REF_REL_NEED)) {
654 usdp->sd_ref = REF_REL_NEED;
655 usdp->sd_shndx = usdp->sd_sym->st_shndx = SHN_ABS;
656 usdp->sd_flags |= FLG_SY_SPECSEC | sdflags_u;
657 usdp->sd_sym->st_info =
658 ELF_ST_INFO(STB_GLOBAL, STT_OBJECT);
659 usdp->sd_isc = NULL;
660 usdp->sd_sym->st_size = 0;
661 usdp->sd_sym->st_value = 0;
662 /* LINTED */
663 usdp->sd_aux->sa_symspec = (Half)sdaux_id;
664
665 /*
666 * If a user hasn't specifically indicated that the
667 * scope of this symbol be made local, then leave it
668 * as global (ie. prevent automatic scoping). The GOT
669 * should be defined protected, whereas all other
670 * special symbols are tagged as no-direct.
671 */
672 if (!SYM_IS_HIDDEN(usdp) &&
673 (sdflags & FLG_SY_DEFAULT)) {
674 usdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
675 if (sdaux_id == SDAUX_ID_GOT) {
676 usdp->sd_flags &= ~FLG_SY_NDIR;
677 usdp->sd_flags |= FLG_SY_PROTECT;
678 usdp->sd_sym->st_other = STV_PROTECTED;
679 } else if (
680 ((usdp->sd_flags & FLG_SY_DIR) == 0) &&
681 ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
682 usdp->sd_flags |= FLG_SY_NDIR;
683 }
684 }
685 usdp->sd_flags |= sdflags;
686
687 /*
688 * If the reference originated from a mapfile ensure
689 * we mark the symbol as used.
690 */
691 if (usdp->sd_flags & FLG_SY_MAPREF)
692 usdp->sd_flags |= FLG_SY_MAPUSED;
693
694 DBG_CALL(Dbg_syms_updated(ofl, usdp, uname));
695 } else {
696 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_RESERVE),
697 uname, usdp->sd_file->ifl_name);
698 }
699 } else {
700 /*
701 * If the symbol does not exist create it.
702 */
703 if ((sym = libld_calloc(sizeof (Sym), 1)) == NULL)
704 return (S_ERROR);
705 sym->st_shndx = SHN_ABS;
706 sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_OBJECT);
707 sym->st_size = 0;
708 sym->st_value = 0;
709 DBG_CALL(Dbg_syms_created(ofl->ofl_lml, uname));
710 if ((usdp = ld_sym_enter(uname, sym, hash, (Ifl_desc *)NULL,
711 ofl, 0, SHN_ABS, (FLG_SY_SPECSEC | sdflags_u), &where)) ==
712 (Sym_desc *)S_ERROR)
713 return (S_ERROR);
714 usdp->sd_ref = REF_REL_NEED;
715 /* LINTED */
716 usdp->sd_aux->sa_symspec = (Half)sdaux_id;
717
718 usdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
719
720 if (sdaux_id == SDAUX_ID_GOT) {
721 usdp->sd_flags |= FLG_SY_PROTECT;
722 usdp->sd_sym->st_other = STV_PROTECTED;
723 } else if ((sdflags & FLG_SY_DEFAULT) &&
724 ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
725 usdp->sd_flags |= FLG_SY_NDIR;
726 }
727 usdp->sd_flags |= sdflags;
728 }
729
730 if (name && (sdp = ld_sym_find(name, SYM_NOHASH, NULL, ofl)) &&
731 (sdp->sd_sym->st_shndx == SHN_UNDEF)) {
732 uchar_t bind;
733
734 /*
735 * If the non-underscore symbol exists and is undefined
736 * convert it to be a local. If the underscore has
737 * sa_symspec set (ie. it was created above) then simulate this
738 * as a weak alias.
739 */
740 sdp->sd_ref = REF_REL_NEED;
741 sdp->sd_shndx = sdp->sd_sym->st_shndx = SHN_ABS;
742 sdp->sd_flags |= FLG_SY_SPECSEC;
743 sdp->sd_isc = NULL;
744 sdp->sd_sym->st_size = 0;
745 sdp->sd_sym->st_value = 0;
746 /* LINTED */
747 sdp->sd_aux->sa_symspec = (Half)sdaux_id;
748 if (usdp->sd_aux->sa_symspec) {
749 usdp->sd_aux->sa_linkndx = 0;
750 sdp->sd_aux->sa_linkndx = 0;
751 bind = STB_WEAK;
752 } else
753 bind = STB_GLOBAL;
754 sdp->sd_sym->st_info = ELF_ST_INFO(bind, STT_OBJECT);
755
756 /*
757 * If a user hasn't specifically indicated the scope of this
758 * symbol be made local then leave it as global (ie. prevent
759 * automatic scoping). The GOT should be defined protected,
760 * whereas all other special symbols are tagged as no-direct.
761 */
762 if (!SYM_IS_HIDDEN(sdp) &&
763 (sdflags & FLG_SY_DEFAULT)) {
764 sdp->sd_aux->sa_overndx = VER_NDX_GLOBAL;
765 if (sdaux_id == SDAUX_ID_GOT) {
766 sdp->sd_flags &= ~FLG_SY_NDIR;
767 sdp->sd_flags |= FLG_SY_PROTECT;
768 sdp->sd_sym->st_other = STV_PROTECTED;
769 } else if (((sdp->sd_flags & FLG_SY_DIR) == 0) &&
770 ((ofl->ofl_flags & FLG_OF_SYMBOLIC) == 0)) {
771 sdp->sd_flags |= FLG_SY_NDIR;
772 }
773 }
774 sdp->sd_flags |= sdflags;
775
776 /*
777 * If the reference originated from a mapfile ensure
778 * we mark the symbol as used.
779 */
780 if (sdp->sd_flags & FLG_SY_MAPREF)
781 sdp->sd_flags |= FLG_SY_MAPUSED;
782
783 DBG_CALL(Dbg_syms_updated(ofl, sdp, name));
784 }
785 return (1);
786 }
787
788
789 /*
790 * Undefined symbols can fall into one of four types:
791 *
792 * - the symbol is really undefined (SHN_UNDEF).
793 *
794 * - versioning has been enabled, however this symbol has not been assigned
795 * to one of the defined versions.
796 *
797 * - the symbol has been defined by an implicitly supplied library, ie. one
798 * which was encounted because it was NEEDED by another library, rather
799 * than from a command line supplied library which would become the only
800 * dependency of the output file being produced.
801 *
802 * - the symbol has been defined by a version of a shared object that is
803 * not permitted for this link-edit.
804 *
805 * In all cases the file who made the first reference to this symbol will have
806 * been recorded via the `sa_rfile' pointer.
807 */
808 typedef enum {
809 UNDEF, NOVERSION, IMPLICIT, NOTAVAIL,
810 BNDLOCAL
811 } Type;
812
813 static const Msg format[] = {
814 MSG_SYM_UND_UNDEF, /* MSG_INTL(MSG_SYM_UND_UNDEF) */
815 MSG_SYM_UND_NOVER, /* MSG_INTL(MSG_SYM_UND_NOVER) */
816 MSG_SYM_UND_IMPL, /* MSG_INTL(MSG_SYM_UND_IMPL) */
817 MSG_SYM_UND_NOTA, /* MSG_INTL(MSG_SYM_UND_NOTA) */
818 MSG_SYM_UND_BNDLOCAL /* MSG_INTL(MSG_SYM_UND_BNDLOCAL) */
819 };
820
821 /*
822 * Issue an undefined symbol message for the given symbol.
823 *
824 * entry:
825 * ofl - Output descriptor
826 * sdp - Undefined symbol to report
827 * type - Type of undefined symbol
828 * ofl_flag - One of 0, FLG_OF_FATAL, or FLG_OF_WARN.
829 * undef_state - Address of variable to be initialized to 0
830 * before the first call to sym_undef_entry, and passed
831 * to each subsequent call. A non-zero value for *undef_state
832 * indicates that this is not the first call in the series.
833 *
834 * exit:
835 * If *undef_state is 0, a title is issued.
836 *
837 * A message for the undefined symbol is issued.
838 *
839 * If ofl_flag is non-zero, its value is OR'd into *undef_state. Otherwise,
840 * all bits other than FLG_OF_FATAL and FLG_OF_WARN are set, in order to
841 * provide *undef_state with a non-zero value. These other bits have
842 * no meaning beyond that, and serve to ensure that *undef_state is
843 * non-zero if sym_undef_entry() has been called.
844 */
845 static void
846 sym_undef_entry(Ofl_desc *ofl, Sym_desc *sdp, Type type, ofl_flag_t ofl_flag,
847 ofl_flag_t *undef_state)
848 {
849 const char *name1, *name2, *name3;
850 Ifl_desc *ifl = sdp->sd_file;
851 Sym_aux *sap = sdp->sd_aux;
852
853 if (*undef_state == 0)
854 ld_eprintf(ofl, ERR_NONE, MSG_INTL(MSG_SYM_FMT_UNDEF),
855 MSG_INTL(MSG_SYM_UNDEF_ITM_11),
856 MSG_INTL(MSG_SYM_UNDEF_ITM_21),
857 MSG_INTL(MSG_SYM_UNDEF_ITM_12),
858 MSG_INTL(MSG_SYM_UNDEF_ITM_22));
859
860 ofl->ofl_flags |= ofl_flag;
861 *undef_state |= ofl_flag ? ofl_flag : ~(FLG_OF_FATAL | FLG_OF_WARN);
862
863 switch (type) {
864 case UNDEF:
865 case BNDLOCAL:
866 name1 = sap->sa_rfile;
867 break;
868 case NOVERSION:
869 name1 = ifl->ifl_name;
870 break;
871 case IMPLICIT:
872 name1 = sap->sa_rfile;
873 name2 = ifl->ifl_name;
874 break;
875 case NOTAVAIL:
876 name1 = sap->sa_rfile;
877 name2 = sap->sa_vfile;
878 name3 = ifl->ifl_verndx[sap->sa_dverndx].vi_name;
879 break;
880 default:
881 return;
882 }
883
884 ld_eprintf(ofl, ERR_NONE, MSG_INTL(format[type]),
885 demangle(sdp->sd_name), name1, name2, name3);
886 }
887
888 /*
889 * If an undef symbol exists naming a bound for the output section,
890 * turn it into a defined symbol with the correct value.
891 *
892 * We set an arbitrary 1KB limit on the resulting symbol names.
893 */
894 static void
895 sym_add_bounds(Ofl_desc *ofl, Os_desc *osp, Word bound)
896 {
897 Sym_desc *bsdp;
898 char symn[1024];
899 size_t nsz;
900
901 switch (bound) {
902 case SDAUX_ID_SECBOUND_START:
903 nsz = snprintf(symn, sizeof (symn), "%s%s",
904 MSG_ORIG(MSG_SYM_SECBOUND_START), osp->os_name + 1);
905 if (nsz >= sizeof (symn))
906 return;
907 break;
908 case SDAUX_ID_SECBOUND_STOP:
909 nsz = snprintf(symn, sizeof (symn), "%s%s",
910 MSG_ORIG(MSG_SYM_SECBOUND_STOP), osp->os_name + 1);
911 if (nsz >= sizeof (symn))
912 return;
913 break;
914 default:
915 assert(0);
916 }
917
918 if ((bsdp = ld_sym_find(symn, SYM_NOHASH, NULL, ofl)) != NULL) {
919 if ((bsdp->sd_shndx != SHN_UNDEF) &&
920 (bsdp->sd_ref == REF_REL_NEED)) {
921 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_RESERVE),
922 symn, bsdp->sd_file->ifl_name);
923 return;
924 }
925
926 DBG_CALL(Dbg_syms_updated(ofl, bsdp, symn));
927
928 bsdp->sd_aux->sa_symspec = bound;
929 bsdp->sd_aux->sa_boundsec = osp;
930 bsdp->sd_flags |= FLG_SY_SPECSEC;
931 bsdp->sd_ref = REF_REL_NEED;
932 bsdp->sd_sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE);
933 bsdp->sd_sym->st_other = STV_PROTECTED;
934 bsdp->sd_isc = NULL;
935 bsdp->sd_sym->st_size = 0;
936 bsdp->sd_sym->st_value = 0;
937 bsdp->sd_shndx = bsdp->sd_sym->st_shndx = SHN_ABS;
938 }
939 }
940
941 /*
942 * At this point all symbol input processing has been completed, therefore
943 * complete the symbol table entries by generating any necessary internal
944 * symbols.
945 */
946 uintptr_t
947 ld_sym_spec(Ofl_desc *ofl)
948 {
949 Sym_desc *sdp;
950 Sg_desc *sgp;
951 Aliste idx1;
952
953 if (ofl->ofl_flags & FLG_OF_RELOBJ)
954 return (1);
955
956 DBG_CALL(Dbg_syms_spec_title(ofl->ofl_lml));
957
958 /*
959 * For each section in the output file, look for symbols named for the
960 * __start/__stop patterns. If references exist, flesh the symbols to
961 * be defined.
962 *
963 * The symbols are given values at the same time as the other special
964 * symbols.
965 */
966 for (APLIST_TRAVERSE(ofl->ofl_segs, idx1, sgp)) {
967 Os_desc *osp;
968 Aliste idx2;
969
970 for (APLIST_TRAVERSE(sgp->sg_osdescs, idx2, osp)) {
971 sym_add_bounds(ofl, osp, SDAUX_ID_SECBOUND_START);
972 sym_add_bounds(ofl, osp, SDAUX_ID_SECBOUND_STOP);
973 }
974 }
975
976 if (sym_add_spec(MSG_ORIG(MSG_SYM_ETEXT), MSG_ORIG(MSG_SYM_ETEXT_U),
977 SDAUX_ID_ETEXT, 0, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
978 ofl) == S_ERROR)
979 return (S_ERROR);
980 if (sym_add_spec(MSG_ORIG(MSG_SYM_EDATA), MSG_ORIG(MSG_SYM_EDATA_U),
981 SDAUX_ID_EDATA, 0, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
982 ofl) == S_ERROR)
983 return (S_ERROR);
984 if (sym_add_spec(MSG_ORIG(MSG_SYM_END), MSG_ORIG(MSG_SYM_END_U),
985 SDAUX_ID_END, FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
986 ofl) == S_ERROR)
987 return (S_ERROR);
988 if (sym_add_spec(MSG_ORIG(MSG_SYM_L_END), MSG_ORIG(MSG_SYM_L_END_U),
989 SDAUX_ID_END, 0, FLG_SY_HIDDEN, ofl) == S_ERROR)
990 return (S_ERROR);
991 if (sym_add_spec(MSG_ORIG(MSG_SYM_L_START), MSG_ORIG(MSG_SYM_L_START_U),
992 SDAUX_ID_START, 0, FLG_SY_HIDDEN, ofl) == S_ERROR)
993 return (S_ERROR);
994
995 /*
996 * Historically we've always produced a _DYNAMIC symbol, even for
997 * static executables (in which case its value will be 0).
998 */
999 if (sym_add_spec(MSG_ORIG(MSG_SYM_DYNAMIC), MSG_ORIG(MSG_SYM_DYNAMIC_U),
1000 SDAUX_ID_DYN, FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
1001 ofl) == S_ERROR)
1002 return (S_ERROR);
1003
1004 if (OFL_ALLOW_DYNSYM(ofl))
1005 if (sym_add_spec(MSG_ORIG(MSG_SYM_PLKTBL),
1006 MSG_ORIG(MSG_SYM_PLKTBL_U), SDAUX_ID_PLT,
1007 FLG_SY_DYNSORT, (FLG_SY_DEFAULT | FLG_SY_EXPDEF),
1008 ofl) == S_ERROR)
1009 return (S_ERROR);
1010
1011 /*
1012 * A GOT reference will be accompanied by the associated GOT symbol.
1013 * Make sure it gets assigned the appropriate special attributes.
1014 */
1015 if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_GOFTBL_U),
1016 SYM_NOHASH, NULL, ofl)) != NULL) && (sdp->sd_ref != REF_DYN_SEEN)) {
1017 if (sym_add_spec(MSG_ORIG(MSG_SYM_GOFTBL),
1018 MSG_ORIG(MSG_SYM_GOFTBL_U), SDAUX_ID_GOT, FLG_SY_DYNSORT,
1019 (FLG_SY_DEFAULT | FLG_SY_EXPDEF), ofl) == S_ERROR)
1020 return (S_ERROR);
1021 }
1022
1023 return (1);
1024 }
1025
1026 /*
1027 * Determine a potential capability symbol's visibility.
1028 *
1029 * The -z symbolcap option transforms an object capabilities relocatable object
1030 * into a symbol capabilities relocatable object. Any global function symbols,
1031 * or initialized global data symbols are candidates for transforming into local
1032 * symbol capabilities definitions. However, if a user indicates that a symbol
1033 * should be demoted to local using a mapfile, then there is no need to
1034 * transform the associated global symbol.
1035 *
1036 * Normally, a symbol's visibility is determined after the symbol resolution
1037 * process, after all symbol state has been gathered and resolved. However,
1038 * for -z symbolcap, this determination is too late. When a global symbol is
1039 * read from an input file we need to determine it's visibility so as to decide
1040 * whether to create a local or not.
1041 *
1042 * If a user has explicitly defined this symbol as having local scope within a
1043 * mapfile, then a symbol of the same name already exists. However, explicit
1044 * local definitions are uncommon, as most mapfiles define the global symbol
1045 * requirements together with an auto-reduction directive '*'. If this state
1046 * has been defined, then we must make sure that the new symbol isn't a type
1047 * that can not be demoted to local.
1048 */
1049 static int
1050 sym_cap_vis(const char *name, Word hash, Sym *sym, Ofl_desc *ofl)
1051 {
1052 Sym_desc *sdp;
1053 uchar_t vis;
1054 avl_index_t where;
1055 sd_flag_t sdflags = 0;
1056
1057 /*
1058 * Determine the visibility of the new symbol.
1059 */
1060 vis = ELF_ST_VISIBILITY(sym->st_other);
1061 switch (vis) {
1062 case STV_EXPORTED:
1063 sdflags |= FLG_SY_EXPORT;
1064 break;
1065 case STV_SINGLETON:
1066 sdflags |= FLG_SY_SINGLE;
1067 break;
1068 }
1069
1070 /*
1071 * Determine whether a symbol definition already exists, and if so
1072 * obtain the visibility.
1073 */
1074 if ((sdp = ld_sym_find(name, hash, &where, ofl)) != NULL)
1075 sdflags |= sdp->sd_flags;
1076
1077 /*
1078 * Determine whether the symbol flags indicate this symbol should be
1079 * hidden.
1080 */
1081 if ((ofl->ofl_flags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM)) &&
1082 ((sdflags & MSK_SY_NOAUTO) == 0))
1083 sdflags |= FLG_SY_HIDDEN;
1084
1085 return ((sdflags & FLG_SY_HIDDEN) == 0);
1086 }
1087
1088 /*
1089 * This routine checks to see if a symbols visibility needs to be reduced to
1090 * either SYMBOLIC or LOCAL. This routine can be called from either
1091 * reloc_init() or sym_validate().
1092 */
1093 void
1094 ld_sym_adjust_vis(Sym_desc *sdp, Ofl_desc *ofl)
1095 {
1096 ofl_flag_t oflags = ofl->ofl_flags;
1097 Sym *sym = sdp->sd_sym;
1098
1099 if ((sdp->sd_ref == REF_REL_NEED) &&
1100 (sdp->sd_sym->st_shndx != SHN_UNDEF)) {
1101 /*
1102 * If auto-reduction/elimination is enabled, reduce any
1103 * non-versioned, and non-local capabilities global symbols.
1104 * A symbol is a candidate for auto-reduction/elimination if:
1105 *
1106 * - the symbol wasn't explicitly defined within a mapfile
1107 * (in which case all the necessary state has been applied
1108 * to the symbol), or
1109 * - the symbol isn't one of the family of reserved
1110 * special symbols (ie. _end, _etext, etc.), or
1111 * - the symbol isn't a SINGLETON, or
1112 * - the symbol wasn't explicitly defined within a version
1113 * definition associated with an input relocatable object.
1114 *
1115 * Indicate that the symbol has been reduced as it may be
1116 * necessary to print these symbols later.
1117 */
1118 if ((oflags & (FLG_OF_AUTOLCL | FLG_OF_AUTOELM)) &&
1119 ((sdp->sd_flags & MSK_SY_NOAUTO) == 0)) {
1120 if ((sdp->sd_flags & FLG_SY_HIDDEN) == 0) {
1121 sdp->sd_flags |=
1122 (FLG_SY_REDUCED | FLG_SY_HIDDEN);
1123 }
1124
1125 if (oflags & (FLG_OF_REDLSYM | FLG_OF_AUTOELM)) {
1126 sdp->sd_flags |= FLG_SY_ELIM;
1127 sym->st_other = STV_ELIMINATE |
1128 (sym->st_other & ~MSK_SYM_VISIBILITY);
1129 } else if (ELF_ST_VISIBILITY(sym->st_other) !=
1130 STV_INTERNAL)
1131 sym->st_other = STV_HIDDEN |
1132 (sym->st_other & ~MSK_SYM_VISIBILITY);
1133 }
1134
1135 /*
1136 * If -Bsymbolic is in effect, and the symbol hasn't explicitly
1137 * been defined nodirect (via a mapfile), then bind the global
1138 * symbol symbolically and assign the STV_PROTECTED visibility
1139 * attribute.
1140 */
1141 if ((oflags & FLG_OF_SYMBOLIC) &&
1142 ((sdp->sd_flags & (FLG_SY_HIDDEN | FLG_SY_NDIR)) == 0)) {
1143 sdp->sd_flags |= FLG_SY_PROTECT;
1144 if (ELF_ST_VISIBILITY(sym->st_other) == STV_DEFAULT)
1145 sym->st_other = STV_PROTECTED |
1146 (sym->st_other & ~MSK_SYM_VISIBILITY);
1147 }
1148 }
1149
1150 /*
1151 * Indicate that this symbol has had it's visibility checked so that
1152 * we don't need to do this investigation again.
1153 */
1154 sdp->sd_flags |= FLG_SY_VISIBLE;
1155 }
1156
1157 /*
1158 * Make sure a symbol definition is local to the object being built.
1159 */
1160 inline static int
1161 ensure_sym_local(Ofl_desc *ofl, Sym_desc *sdp, const char *str)
1162 {
1163 if (sdp->sd_sym->st_shndx == SHN_UNDEF) {
1164 if (str) {
1165 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_UNDEF),
1166 str, demangle((char *)sdp->sd_name));
1167 }
1168 return (1);
1169 }
1170 if (sdp->sd_ref != REF_REL_NEED) {
1171 if (str) {
1172 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_SYM_EXTERN),
1173 str, demangle((char *)sdp->sd_name),
1174 sdp->sd_file->ifl_name);
1175 }
1176 return (1);
1177 }
1178
1179 sdp->sd_flags |= FLG_SY_UPREQD;
1180 if (sdp->sd_isc) {
1181 sdp->sd_isc->is_flags |= FLG_IS_SECTREF;
1182 sdp->sd_isc->is_file->ifl_flags |= FLG_IF_FILEREF;
1183 }
1184 return (0);
1185 }
1186
1187 /*
1188 * Make sure all the symbol definitions required for initarray, finiarray, or
1189 * preinitarray's are local to the object being built.
1190 */
1191 static int
1192 ensure_array_local(Ofl_desc *ofl, APlist *apl, const char *str)
1193 {
1194 Aliste idx;
1195 Sym_desc *sdp;
1196 int ret = 0;
1197
1198 for (APLIST_TRAVERSE(apl, idx, sdp))
1199 ret += ensure_sym_local(ofl, sdp, str);
1200
1201 return (ret);
1202 }
1203
1204 /*
1205 * After all symbol table input processing has been finished, and all relocation
1206 * counting has been carried out (ie. no more symbols will be read, generated,
1207 * or modified), validate and count the relevant entries:
1208 *
1209 * - check and print any undefined symbols remaining. Note that if a symbol
1210 * has been defined by virtue of the inclusion of an implicit shared
1211 * library, it is still classed as undefined.
1212 *
1213 * - count the number of global needed symbols together with the size of
1214 * their associated name strings (if scoping has been indicated these
1215 * symbols may be reduced to locals).
1216 *
1217 * - establish the size and alignment requirements for the global .bss
1218 * section (the alignment of this section is based on the first symbol
1219 * that it will contain).
1220 */
1221 uintptr_t
1222 ld_sym_validate(Ofl_desc *ofl)
1223 {
1224 Sym_avlnode *sav;
1225 Sym_desc *sdp;
1226 Sym *sym;
1227 ofl_flag_t oflags = ofl->ofl_flags;
1228 ofl_flag_t undef = 0, needed = 0, verdesc = 0;
1229 Xword bssalign = 0, tlsalign = 0;
1230 Boolean need_bss, need_tlsbss;
1231 Xword bsssize = 0, tlssize = 0;
1232 #if defined(_ELF64)
1233 Xword lbssalign = 0, lbsssize = 0;
1234 Boolean need_lbss;
1235 #endif
1236 int ret, allow_ldynsym;
1237 uchar_t type;
1238 ofl_flag_t undef_state = 0;
1239
1240 DBG_CALL(Dbg_basic_validate(ofl->ofl_lml));
1241
1242 /*
1243 * The need_XXX booleans are used to determine whether we need to
1244 * create each type of bss section. We used to create these sections
1245 * if the sum of the required sizes for each type were non-zero.
1246 * However, it is possible for a compiler to generate COMMON variables
1247 * of zero-length and this tricks that logic --- even zero-length
1248 * symbols need an output section.
1249 */
1250 need_bss = need_tlsbss = FALSE;
1251 #if defined(_ELF64)
1252 need_lbss = FALSE;
1253 #endif
1254
1255 /*
1256 * Determine how undefined symbols are handled:
1257 *
1258 * fatal:
1259 * If this link-edit calls for no undefined symbols to remain
1260 * (this is the default case when generating an executable but
1261 * can be enforced for any object using -z defs), a fatal error
1262 * condition will be indicated.
1263 *
1264 * warning:
1265 * If we're creating a shared object, and either the -Bsymbolic
1266 * flag is set, or the user has turned on the -z guidance feature,
1267 * then a non-fatal warning is issued for each symbol.
1268 *
1269 * ignore:
1270 * In all other cases, undefined symbols are quietly allowed.
1271 */
1272 if (oflags & FLG_OF_NOUNDEF) {
1273 undef = FLG_OF_FATAL;
1274 } else if (oflags & FLG_OF_SHAROBJ) {
1275 if ((oflags & FLG_OF_SYMBOLIC) ||
1276 OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))
1277 undef = FLG_OF_WARN;
1278 }
1279
1280 /*
1281 * If the symbol is referenced from an implicitly included shared object
1282 * (ie. it's not on the NEEDED list) then the symbol is also classified
1283 * as undefined and a fatal error condition will be indicated.
1284 */
1285 if ((oflags & FLG_OF_NOUNDEF) || !(oflags & FLG_OF_SHAROBJ))
1286 needed = FLG_OF_FATAL;
1287 else if ((oflags & FLG_OF_SHAROBJ) &&
1288 OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS))
1289 needed = FLG_OF_WARN;
1290
1291 /*
1292 * If the output image is being versioned, then all symbol definitions
1293 * must be associated with a version. Any symbol that isn't associated
1294 * with a version is classified as undefined, and a fatal error
1295 * condition is indicated.
1296 */
1297 if ((oflags & FLG_OF_VERDEF) && (ofl->ofl_vercnt > VER_NDX_GLOBAL))
1298 verdesc = FLG_OF_FATAL;
1299
1300 allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
1301
1302 if (allow_ldynsym) {
1303 /*
1304 * Normally, we disallow symbols with 0 size from appearing
1305 * in a dyn[sym|tls]sort section. However, there are some
1306 * symbols that serve special purposes that we want to exempt
1307 * from this rule. Look them up, and set their
1308 * FLG_SY_DYNSORT flag.
1309 */
1310 static const char *special[] = {
1311 MSG_ORIG(MSG_SYM_INIT_U), /* _init */
1312 MSG_ORIG(MSG_SYM_FINI_U), /* _fini */
1313 MSG_ORIG(MSG_SYM_START), /* _start */
1314 NULL
1315 };
1316 int i;
1317
1318 for (i = 0; special[i] != NULL; i++) {
1319 if (((sdp = ld_sym_find(special[i],
1320 SYM_NOHASH, NULL, ofl)) != NULL) &&
1321 (sdp->sd_sym->st_size == 0)) {
1322 if (ld_sym_copy(sdp) == S_ERROR)
1323 return (S_ERROR);
1324 sdp->sd_flags |= FLG_SY_DYNSORT;
1325 }
1326 }
1327 }
1328
1329 /*
1330 * Collect and validate the globals from the internal symbol table.
1331 */
1332 for (sav = avl_first(&ofl->ofl_symavl); sav;
1333 sav = AVL_NEXT(&ofl->ofl_symavl, sav)) {
1334 Is_desc *isp;
1335 int undeferr = 0;
1336 uchar_t vis;
1337
1338 sdp = sav->sav_sdp;
1339
1340 /*
1341 * If undefined symbols are allowed, and we're not being
1342 * asked to supply guidance, ignore any symbols that are
1343 * not needed.
1344 */
1345 if (!(oflags & FLG_OF_NOUNDEF) &&
1346 !OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS) &&
1347 (sdp->sd_ref == REF_DYN_SEEN))
1348 continue;
1349
1350 /*
1351 * If the symbol originates from an external or parent mapfile
1352 * reference and hasn't been matched to a reference from a
1353 * relocatable object, ignore it.
1354 */
1355 if ((sdp->sd_flags & (FLG_SY_EXTERN | FLG_SY_PARENT)) &&
1356 ((sdp->sd_flags & FLG_SY_MAPUSED) == 0)) {
1357 sdp->sd_flags |= FLG_SY_INVALID;
1358 continue;
1359 }
1360
1361 sym = sdp->sd_sym;
1362 type = ELF_ST_TYPE(sym->st_info);
1363
1364 /*
1365 * Sanity check TLS.
1366 */
1367 if ((type == STT_TLS) && (sym->st_size != 0) &&
1368 (sym->st_shndx != SHN_UNDEF) &&
1369 (sym->st_shndx != SHN_COMMON)) {
1370 Is_desc *isp = sdp->sd_isc;
1371 Ifl_desc *ifl = sdp->sd_file;
1372
1373 if ((isp == NULL) || (isp->is_shdr == NULL) ||
1374 ((isp->is_shdr->sh_flags & SHF_TLS) == 0)) {
1375 ld_eprintf(ofl, ERR_FATAL,
1376 MSG_INTL(MSG_SYM_TLS),
1377 demangle(sdp->sd_name), ifl->ifl_name);
1378 continue;
1379 }
1380 }
1381
1382 if ((sdp->sd_flags & FLG_SY_VISIBLE) == 0)
1383 ld_sym_adjust_vis(sdp, ofl);
1384
1385 if ((sdp->sd_flags & FLG_SY_REDUCED) &&
1386 (oflags & FLG_OF_PROCRED)) {
1387 DBG_CALL(Dbg_syms_reduce(ofl, DBG_SYM_REDUCE_GLOBAL,
1388 sdp, 0, 0));
1389 }
1390
1391 /*
1392 * Record any STV_SINGLETON existence.
1393 */
1394 if ((vis = ELF_ST_VISIBILITY(sym->st_other)) == STV_SINGLETON)
1395 ofl->ofl_dtflags_1 |= DF_1_SINGLETON;
1396
1397 /*
1398 * If building a shared object or executable, and this is a
1399 * non-weak UNDEF symbol with reduced visibility (STV_*), then
1400 * give a fatal error.
1401 */
1402 if (((oflags & FLG_OF_RELOBJ) == 0) &&
1403 (sym->st_shndx == SHN_UNDEF) &&
1404 (ELF_ST_BIND(sym->st_info) != STB_WEAK)) {
1405 if (vis && (vis != STV_SINGLETON)) {
1406 sym_undef_entry(ofl, sdp, BNDLOCAL,
1407 FLG_OF_FATAL, &undef_state);
1408 continue;
1409 }
1410 }
1411
1412 /*
1413 * If this symbol is defined in a non-allocatable section,
1414 * reduce it to local symbol.
1415 */
1416 if (((isp = sdp->sd_isc) != 0) && isp->is_shdr &&
1417 ((isp->is_shdr->sh_flags & SHF_ALLOC) == 0)) {
1418 sdp->sd_flags |= (FLG_SY_REDUCED | FLG_SY_HIDDEN);
1419 }
1420
1421 /*
1422 * If this symbol originated as a SHN_SUNW_IGNORE, it will have
1423 * been processed as an SHN_UNDEF. Return the symbol to its
1424 * original index for validation, and propagation to the output
1425 * file.
1426 */
1427 if (sdp->sd_flags & FLG_SY_IGNORE)
1428 sdp->sd_shndx = SHN_SUNW_IGNORE;
1429
1430 if (undef) {
1431 /*
1432 * If a non-weak reference remains undefined, or if a
1433 * mapfile reference is not bound to the relocatable
1434 * objects that make up the object being built, we have
1435 * a fatal error.
1436 *
1437 * The exceptions are symbols which are defined to be
1438 * found in the parent (FLG_SY_PARENT), which is really
1439 * only meaningful for direct binding, or are defined
1440 * external (FLG_SY_EXTERN) so as to suppress -zdefs
1441 * errors.
1442 *
1443 * Register symbols are always allowed to be UNDEF.
1444 *
1445 * Note that we don't include references created via -u
1446 * in the same shared object binding test. This is for
1447 * backward compatibility, in that a number of archive
1448 * makefile rules used -u to cause archive extraction.
1449 * These same rules have been cut and pasted to apply
1450 * to shared objects, and thus although the -u reference
1451 * is redundant, flagging it as fatal could cause some
1452 * build to fail. Also we have documented the use of
1453 * -u as a mechanism to cause binding to weak version
1454 * definitions, thus giving users an error condition
1455 * would be incorrect.
1456 */
1457 if (!(sdp->sd_flags & FLG_SY_REGSYM) &&
1458 ((sym->st_shndx == SHN_UNDEF) &&
1459 ((ELF_ST_BIND(sym->st_info) != STB_WEAK) &&
1460 ((sdp->sd_flags &
1461 (FLG_SY_PARENT | FLG_SY_EXTERN)) == 0)) ||
1462 ((sdp->sd_flags &
1463 (FLG_SY_MAPREF | FLG_SY_MAPUSED | FLG_SY_HIDDEN |
1464 FLG_SY_PROTECT)) == FLG_SY_MAPREF))) {
1465 sym_undef_entry(ofl, sdp, UNDEF, undef,
1466 &undef_state);
1467 undeferr = 1;
1468 }
1469
1470 } else {
1471 /*
1472 * For building things like shared objects (or anything
1473 * -znodefs), undefined symbols are allowed.
1474 *
1475 * If a mapfile reference remains undefined the user
1476 * would probably like a warning at least (they've
1477 * usually mis-spelt the reference). Refer to the above
1478 * comments for discussion on -u references, which
1479 * are not tested for in the same manner.
1480 */
1481 if ((sdp->sd_flags &
1482 (FLG_SY_MAPREF | FLG_SY_MAPUSED)) ==
1483 FLG_SY_MAPREF) {
1484 sym_undef_entry(ofl, sdp, UNDEF, FLG_OF_WARN,
1485 &undef_state);
1486 undeferr = 1;
1487 }
1488 }
1489
1490 /*
1491 * If this symbol comes from a dependency mark the dependency
1492 * as required (-z ignore can result in unused dependencies
1493 * being dropped). If we need to record dependency versioning
1494 * information indicate what version of the needed shared object
1495 * this symbol is part of. Flag the symbol as undefined if it
1496 * has not been made available to us.
1497 */
1498 if ((sdp->sd_ref == REF_DYN_NEED) &&
1499 (!(sdp->sd_flags & FLG_SY_REFRSD))) {
1500 sdp->sd_file->ifl_flags |= FLG_IF_DEPREQD;
1501
1502 /*
1503 * Capture that we've bound to a symbol that doesn't
1504 * allow being directly bound to.
1505 */
1506 if (sdp->sd_flags & FLG_SY_NDIR)
1507 ofl->ofl_flags1 |= FLG_OF1_NGLBDIR;
1508
1509 if (sdp->sd_file->ifl_vercnt) {
1510 int vndx;
1511 Ver_index *vip;
1512
1513 vndx = sdp->sd_aux->sa_dverndx;
1514 vip = &sdp->sd_file->ifl_verndx[vndx];
1515 if (vip->vi_flags & FLG_VER_AVAIL) {
1516 vip->vi_flags |= FLG_VER_REFER;
1517 } else {
1518 sym_undef_entry(ofl, sdp, NOTAVAIL,
1519 FLG_OF_FATAL, &undef_state);
1520 continue;
1521 }
1522 }
1523 }
1524
1525 /*
1526 * Test that we do not bind to symbol supplied from an implicit
1527 * shared object. If a binding is from a weak reference it can
1528 * be ignored.
1529 */
1530 if (needed && !undeferr && (sdp->sd_flags & FLG_SY_GLOBREF) &&
1531 (sdp->sd_ref == REF_DYN_NEED) &&
1532 (sdp->sd_flags & FLG_SY_NOTAVAIL)) {
1533 sym_undef_entry(ofl, sdp, IMPLICIT, needed,
1534 &undef_state);
1535 if (needed == FLG_OF_FATAL)
1536 continue;
1537 }
1538
1539 /*
1540 * Test that a symbol isn't going to be reduced to local scope
1541 * which actually wants to bind to a shared object - if so it's
1542 * a fatal error.
1543 */
1544 if ((sdp->sd_ref == REF_DYN_NEED) &&
1545 (sdp->sd_flags & (FLG_SY_HIDDEN | FLG_SY_PROTECT))) {
1546 sym_undef_entry(ofl, sdp, BNDLOCAL, FLG_OF_FATAL,
1547 &undef_state);
1548 continue;
1549 }
1550
1551 /*
1552 * If the output image is to be versioned then all symbol
1553 * definitions must be associated with a version. Remove any
1554 * versioning that might be left associated with an undefined
1555 * symbol.
1556 */
1557 if (verdesc && (sdp->sd_ref == REF_REL_NEED)) {
1558 if (sym->st_shndx == SHN_UNDEF) {
1559 if (sdp->sd_aux && sdp->sd_aux->sa_overndx)
1560 sdp->sd_aux->sa_overndx = 0;
1561 } else {
1562 if (!SYM_IS_HIDDEN(sdp) && sdp->sd_aux &&
1563 (sdp->sd_aux->sa_overndx == 0)) {
1564 sym_undef_entry(ofl, sdp, NOVERSION,
1565 verdesc, &undef_state);
1566 continue;
1567 }
1568 }
1569 }
1570
1571 /*
1572 * If we don't need the symbol there's no need to process it
1573 * any further.
1574 */
1575 if (sdp->sd_ref == REF_DYN_SEEN)
1576 continue;
1577
1578 /*
1579 * Calculate the size and alignment requirements for the global
1580 * .bss and .tls sections. If we're building a relocatable
1581 * object only account for scoped COMMON symbols (these will
1582 * be converted to .bss references).
1583 *
1584 * When -z nopartial is in effect, partially initialized
1585 * symbols are directed to the special .data section
1586 * created for that purpose (ofl->ofl_isparexpn).
1587 * Otherwise, partially initialized symbols go to .bss.
1588 *
1589 * Also refer to make_mvsections() in sunwmove.c
1590 */
1591 if ((sym->st_shndx == SHN_COMMON) &&
1592 (((oflags & FLG_OF_RELOBJ) == 0) ||
1593 (SYM_IS_HIDDEN(sdp) && (oflags & FLG_OF_PROCRED)))) {
1594 if ((sdp->sd_move == NULL) ||
1595 ((sdp->sd_flags & FLG_SY_PAREXPN) == 0)) {
1596 if (type != STT_TLS) {
1597 need_bss = TRUE;
1598 bsssize = (Xword)S_ROUND(bsssize,
1599 sym->st_value) + sym->st_size;
1600 if (sym->st_value > bssalign)
1601 bssalign = sym->st_value;
1602 } else {
1603 need_tlsbss = TRUE;
1604 tlssize = (Xword)S_ROUND(tlssize,
1605 sym->st_value) + sym->st_size;
1606 if (sym->st_value > tlsalign)
1607 tlsalign = sym->st_value;
1608 }
1609 }
1610 }
1611
1612 #if defined(_ELF64)
1613 /*
1614 * Calculate the size and alignment requirement for the global
1615 * .lbss. TLS or partially initialized symbols do not need to be
1616 * considered yet.
1617 */
1618 if ((ld_targ.t_m.m_mach == EM_AMD64) &&
1619 (sym->st_shndx == SHN_X86_64_LCOMMON)) {
1620 need_lbss = TRUE;
1621 lbsssize = (Xword)S_ROUND(lbsssize, sym->st_value) +
1622 sym->st_size;
1623 if (sym->st_value > lbssalign)
1624 lbssalign = sym->st_value;
1625 }
1626 #endif
1627 /*
1628 * If a symbol was referenced via the command line
1629 * (ld -u <>, ...), then this counts as a reference against the
1630 * symbol. Mark any section that symbol is defined in.
1631 */
1632 if (((isp = sdp->sd_isc) != 0) &&
1633 (sdp->sd_flags & FLG_SY_CMDREF)) {
1634 isp->is_flags |= FLG_IS_SECTREF;
1635 isp->is_file->ifl_flags |= FLG_IF_FILEREF;
1636 }
1637
1638 /*
1639 * Update the symbol count and the associated name string size.
1640 * Note, a capabilities symbol must remain as visible as a
1641 * global symbol. However, the runtime linker recognizes the
1642 * hidden requirement and ensures the symbol isn't made globally
1643 * available at runtime.
1644 */
1645 if (SYM_IS_HIDDEN(sdp) && (oflags & FLG_OF_PROCRED)) {
1646 /*
1647 * If any reductions are being processed, keep a count
1648 * of eliminated symbols, and if the symbol is being
1649 * reduced to local, count it's size for the .symtab.
1650 */
1651 if (sdp->sd_flags & FLG_SY_ELIM) {
1652 ofl->ofl_elimcnt++;
1653 } else {
1654 ofl->ofl_scopecnt++;
1655 if ((((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
1656 sym->st_name) && (st_insert(ofl->ofl_strtab,
1657 sdp->sd_name) == -1))
1658 return (S_ERROR);
1659 if (allow_ldynsym && sym->st_name &&
1660 ldynsym_symtype[type]) {
1661 ofl->ofl_dynscopecnt++;
1662 if (st_insert(ofl->ofl_dynstrtab,
1663 sdp->sd_name) == -1)
1664 return (S_ERROR);
1665 /* Include it in sort section? */
1666 DYNSORT_COUNT(sdp, sym, type, ++);
1667 }
1668 }
1669 } else {
1670 ofl->ofl_globcnt++;
1671
1672 /*
1673 * Check to see if this global variable should go into
1674 * a sort section. Sort sections require a
1675 * .SUNW_ldynsym section, so, don't check unless a
1676 * .SUNW_ldynsym is allowed.
1677 */
1678 if (allow_ldynsym)
1679 DYNSORT_COUNT(sdp, sym, type, ++);
1680
1681 /*
1682 * If global direct bindings are in effect, or this
1683 * symbol has bound to a dependency which was specified
1684 * as requiring direct bindings, and it hasn't
1685 * explicitly been defined as a non-direct binding
1686 * symbol, mark it.
1687 */
1688 if (((ofl->ofl_dtflags_1 & DF_1_DIRECT) || (isp &&
1689 (isp->is_file->ifl_flags & FLG_IF_DIRECT))) &&
1690 ((sdp->sd_flags & FLG_SY_NDIR) == 0))
1691 sdp->sd_flags |= FLG_SY_DIR;
1692
1693 /*
1694 * Insert the symbol name.
1695 */
1696 if (((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
1697 sym->st_name) {
1698 if (st_insert(ofl->ofl_strtab,
1699 sdp->sd_name) == -1)
1700 return (S_ERROR);
1701
1702 if (!(ofl->ofl_flags & FLG_OF_RELOBJ) &&
1703 (st_insert(ofl->ofl_dynstrtab,
1704 sdp->sd_name) == -1))
1705 return (S_ERROR);
1706 }
1707
1708 /*
1709 * If this section offers a global symbol - record that
1710 * fact.
1711 */
1712 if (isp) {
1713 isp->is_flags |= FLG_IS_SECTREF;
1714 isp->is_file->ifl_flags |= FLG_IF_FILEREF;
1715 }
1716 }
1717 }
1718
1719 /*
1720 * Guidance: Use -z defs|nodefs when building shared objects.
1721 *
1722 * Our caller issues this, unless we mask it out here. So we mask it
1723 * out unless we've issued at least one warnings or fatal error.
1724 */
1725 if (!((oflags & FLG_OF_SHAROBJ) && OFL_GUIDANCE(ofl, FLG_OFG_NO_DEFS) &&
1726 (undef_state & (FLG_OF_FATAL | FLG_OF_WARN))))
1727 ofl->ofl_guideflags |= FLG_OFG_NO_DEFS;
1728
1729 /*
1730 * If we've encountered a fatal error during symbol validation then
1731 * return now.
1732 */
1733 if (ofl->ofl_flags & FLG_OF_FATAL)
1734 return (1);
1735
1736 /*
1737 * Now that symbol resolution is completed, scan any register symbols.
1738 * From now on, we're only interested in those that contribute to the
1739 * output file.
1740 */
1741 if (ofl->ofl_regsyms) {
1742 int ndx;
1743
1744 for (ndx = 0; ndx < ofl->ofl_regsymsno; ndx++) {
1745 if ((sdp = ofl->ofl_regsyms[ndx]) == NULL)
1746 continue;
1747 if (sdp->sd_ref != REF_REL_NEED) {
1748 ofl->ofl_regsyms[ndx] = NULL;
1749 continue;
1750 }
1751
1752 ofl->ofl_regsymcnt++;
1753 if (sdp->sd_sym->st_name == 0)
1754 sdp->sd_name = MSG_ORIG(MSG_STR_EMPTY);
1755
1756 if (SYM_IS_HIDDEN(sdp) ||
1757 (ELF_ST_BIND(sdp->sd_sym->st_info) == STB_LOCAL))
1758 ofl->ofl_lregsymcnt++;
1759 }
1760 }
1761
1762 /*
1763 * Generate the .bss section now that we know its size and alignment.
1764 */
1765 if (need_bss) {
1766 if (ld_make_bss(ofl, bsssize, bssalign,
1767 ld_targ.t_id.id_bss) == S_ERROR)
1768 return (S_ERROR);
1769 }
1770 if (need_tlsbss) {
1771 if (ld_make_bss(ofl, tlssize, tlsalign,
1772 ld_targ.t_id.id_tlsbss) == S_ERROR)
1773 return (S_ERROR);
1774 }
1775 #if defined(_ELF64)
1776 if ((ld_targ.t_m.m_mach == EM_AMD64) &&
1777 need_lbss && !(oflags & FLG_OF_RELOBJ)) {
1778 if (ld_make_bss(ofl, lbsssize, lbssalign,
1779 ld_targ.t_id.id_lbss) == S_ERROR)
1780 return (S_ERROR);
1781 }
1782 #endif
1783 /*
1784 * Determine what entry point symbol we need, and if found save its
1785 * symbol descriptor so that we can update the ELF header entry with the
1786 * symbols value later (see update_oehdr). Make sure the symbol is
1787 * tagged to ensure its update in case -s is in effect. Use any -e
1788 * option first, or the default entry points `_start' and `main'.
1789 */
1790 ret = 0;
1791 if (ofl->ofl_entry) {
1792 if ((sdp = ld_sym_find(ofl->ofl_entry, SYM_NOHASH,
1793 NULL, ofl)) == NULL) {
1794 ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ARG_NOENTRY),
1795 ofl->ofl_entry);
1796 ret++;
1797 } else if (ensure_sym_local(ofl, sdp,
1798 MSG_INTL(MSG_SYM_ENTRY)) != 0) {
1799 ret++;
1800 } else {
1801 ofl->ofl_entry = (void *)sdp;
1802 }
1803 } else if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_START),
1804 SYM_NOHASH, NULL, ofl)) != NULL) && (ensure_sym_local(ofl,
1805 sdp, 0) == 0)) {
1806 ofl->ofl_entry = (void *)sdp;
1807
1808 } else if (((sdp = ld_sym_find(MSG_ORIG(MSG_SYM_MAIN),
1809 SYM_NOHASH, NULL, ofl)) != NULL) && (ensure_sym_local(ofl,
1810 sdp, 0) == 0)) {
1811 ofl->ofl_entry = (void *)sdp;
1812 }
1813
1814 /*
1815 * If ld -zdtrace=<sym> was given, then validate that the symbol is
1816 * defined within the current object being built.
1817 */
1818 if ((sdp = ofl->ofl_dtracesym) != 0)
1819 ret += ensure_sym_local(ofl, sdp, MSG_ORIG(MSG_STR_DTRACE));
1820
1821 /*
1822 * If any initarray, finiarray or preinitarray functions have been
1823 * requested, make sure they are defined within the current object
1824 * being built.
1825 */
1826 if (ofl->ofl_initarray) {
1827 ret += ensure_array_local(ofl, ofl->ofl_initarray,
1828 MSG_ORIG(MSG_SYM_INITARRAY));
1829 }
1830 if (ofl->ofl_finiarray) {
1831 ret += ensure_array_local(ofl, ofl->ofl_finiarray,
1832 MSG_ORIG(MSG_SYM_FINIARRAY));
1833 }
1834 if (ofl->ofl_preiarray) {
1835 ret += ensure_array_local(ofl, ofl->ofl_preiarray,
1836 MSG_ORIG(MSG_SYM_PREINITARRAY));
1837 }
1838
1839 if (ret)
1840 return (S_ERROR);
1841
1842 /*
1843 * If we're required to record any needed dependencies versioning
1844 * information calculate it now that all symbols have been validated.
1845 */
1846 if ((oflags & (FLG_OF_VERNEED | FLG_OF_NOVERSEC)) == FLG_OF_VERNEED)
1847 return (ld_vers_check_need(ofl));
1848 else
1849 return (1);
1850 }
1851
1852 /*
1853 * qsort(3c) comparison function. As an optimization for associating weak
1854 * symbols to their strong counterparts sort global symbols according to their
1855 * section index, address and binding.
1856 */
1857 static int
1858 compare(const void *sdpp1, const void *sdpp2)
1859 {
1860 Sym_desc *sdp1 = *((Sym_desc **)sdpp1);
1861 Sym_desc *sdp2 = *((Sym_desc **)sdpp2);
1862 Sym *sym1, *sym2;
1863 uchar_t bind1, bind2;
1864
1865 /*
1866 * Symbol descriptors may be zero, move these to the front of the
1867 * sorted array.
1868 */
1869 if (sdp1 == NULL)
1870 return (-1);
1871 if (sdp2 == NULL)
1872 return (1);
1873
1874 sym1 = sdp1->sd_sym;
1875 sym2 = sdp2->sd_sym;
1876
1877 /*
1878 * Compare the symbols section index. This is important when sorting
1879 * the symbol tables of relocatable objects. In this case, a symbols
1880 * value is the offset within the associated section, and thus many
1881 * symbols can have the same value, but are effectively different
1882 * addresses.
1883 */
1884 if (sym1->st_shndx > sym2->st_shndx)
1885 return (1);
1886 if (sym1->st_shndx < sym2->st_shndx)
1887 return (-1);
1888
1889 /*
1890 * Compare the symbols value (address).
1891 */
1892 if (sym1->st_value > sym2->st_value)
1893 return (1);
1894 if (sym1->st_value < sym2->st_value)
1895 return (-1);
1896
1897 bind1 = ELF_ST_BIND(sym1->st_info);
1898 bind2 = ELF_ST_BIND(sym2->st_info);
1899
1900 /*
1901 * If two symbols have the same address place the weak symbol before
1902 * any strong counterpart.
1903 */
1904 if (bind1 > bind2)
1905 return (-1);
1906 if (bind1 < bind2)
1907 return (1);
1908
1909 return (0);
1910 }
1911
1912 /*
1913 * Issue a MSG_SYM_BADADDR error from ld_sym_process(). This error
1914 * is issued when a symbol address/size is not contained by the
1915 * target section.
1916 *
1917 * Such objects are at least partially corrupt, and the user would
1918 * be well advised to be skeptical of them, and to ask their compiler
1919 * supplier to fix the problem. However, a distinction needs to be
1920 * made between symbols that reference readonly text, and those that
1921 * access writable data. Other than throwing off profiling results,
1922 * the readonly section case is less serious. We have encountered
1923 * such objects in the field. In order to allow existing objects
1924 * to continue working, we issue a warning rather than a fatal error
1925 * if the symbol is against readonly text. Other cases are fatal.
1926 */
1927 static void
1928 issue_badaddr_msg(Ifl_desc *ifl, Ofl_desc *ofl, Sym_desc *sdp,
1929 Sym *sym, Word shndx)
1930 {
1931 Error err;
1932 const char *msg;
1933
1934 if ((sdp->sd_isc->is_shdr->sh_flags & (SHF_WRITE | SHF_ALLOC)) ==
1935 SHF_ALLOC) {
1936 msg = MSG_INTL(MSG_SYM_BADADDR_ROTXT);
1937 err = ERR_WARNING;
1938 } else {
1939 msg = MSG_INTL(MSG_SYM_BADADDR);
1940 err = ERR_FATAL;
1941 }
1942
1943 ld_eprintf(ofl, err, msg, demangle(sdp->sd_name),
1944 ifl->ifl_name, shndx, sdp->sd_isc->is_name,
1945 EC_XWORD(sdp->sd_isc->is_shdr->sh_size),
1946 EC_XWORD(sym->st_value), EC_XWORD(sym->st_size));
1947 }
1948
1949 /*
1950 * Global symbols that are candidates for translation to local capability
1951 * symbols under -z symbolcap, are maintained on a local symbol list. Once
1952 * all symbols of a file are processed, this list is traversed to cull any
1953 * unnecessary weak symbol aliases.
1954 */
1955 typedef struct {
1956 Sym_desc *c_nsdp; /* new lead symbol */
1957 Sym_desc *c_osdp; /* original symbol */
1958 Cap_group *c_group; /* symbol capability group */
1959 Word c_ndx; /* symbol index */
1960 } Cap_pair;
1961
1962 /*
1963 * Process the symbol table for the specified input file. At this point all
1964 * input sections from this input file have been assigned an input section
1965 * descriptor which is saved in the `ifl_isdesc' array.
1966 *
1967 * - local symbols are saved (as is) if the input file is a relocatable
1968 * object
1969 *
1970 * - global symbols are added to the linkers internal symbol table if they
1971 * are not already present, otherwise a symbol resolution function is
1972 * called upon to resolve the conflict.
1973 */
1974 uintptr_t
1975 ld_sym_process(Is_desc *isc, Ifl_desc *ifl, Ofl_desc *ofl)
1976 {
1977 /*
1978 * This macro tests the given symbol to see if it is out of
1979 * range relative to the section it references.
1980 *
1981 * entry:
1982 * - ifl is a relative object (ET_REL)
1983 * _sdp - Symbol descriptor
1984 * _sym - Symbol
1985 * _type - Symbol type
1986 *
1987 * The following are tested:
1988 * - Symbol length is non-zero
1989 * - Symbol type is a type that references code or data
1990 * - Referenced section is not 0 (indicates an UNDEF symbol)
1991 * and is not in the range of special values above SHN_LORESERVE
1992 * (excluding SHN_XINDEX, which is OK).
1993 * - We have a valid section header for the target section
1994 *
1995 * If the above are all true, and the symbol position is not
1996 * contained by the target section, this macro evaluates to
1997 * True (1). Otherwise, False(0).
1998 */
1999 #define SYM_LOC_BADADDR(_sdp, _sym, _type) \
2000 (_sym->st_size && dynsymsort_symtype[_type] && \
2001 (_sym->st_shndx != SHN_UNDEF) && \
2002 ((_sym->st_shndx < SHN_LORESERVE) || \
2003 (_sym->st_shndx == SHN_XINDEX)) && \
2004 _sdp->sd_isc && _sdp->sd_isc->is_shdr && \
2005 ((_sym->st_value + _sym->st_size) > _sdp->sd_isc->is_shdr->sh_size))
2006
2007 Conv_inv_buf_t inv_buf;
2008 Sym *sym = (Sym *)isc->is_indata->d_buf;
2009 Word *symshndx = NULL;
2010 Shdr *shdr = isc->is_shdr;
2011 Sym_desc *sdp;
2012 size_t strsize;
2013 char *strs;
2014 uchar_t type, bind;
2015 Word ndx, hash, local, total;
2016 uchar_t osabi = ifl->ifl_ehdr->e_ident[EI_OSABI];
2017 Half mach = ifl->ifl_ehdr->e_machine;
2018 Half etype = ifl->ifl_ehdr->e_type;
2019 int etype_rel;
2020 const char *symsecname, *strsecname;
2021 Word symsecndx;
2022 avl_index_t where;
2023 int test_gnu_hidden_bit, weak;
2024 Cap_desc *cdp = NULL;
2025 Alist *cappairs = NULL;
2026
2027 /*
2028 * Its possible that a file may contain more that one symbol table,
2029 * ie. .dynsym and .symtab in a shared library. Only process the first
2030 * table (here, we assume .dynsym comes before .symtab).
2031 */
2032 if (ifl->ifl_symscnt)
2033 return (1);
2034
2035 if (isc->is_symshndx)
2036 symshndx = isc->is_symshndx->is_indata->d_buf;
2037
2038 DBG_CALL(Dbg_syms_process(ofl->ofl_lml, ifl));
2039
2040 symsecndx = isc->is_scnndx;
2041 if (isc->is_name)
2042 symsecname = isc->is_name;
2043 else
2044 symsecname = MSG_ORIG(MSG_STR_EMPTY);
2045
2046 /*
2047 * From the symbol tables section header information determine which
2048 * strtab table is needed to locate the actual symbol names.
2049 */
2050 if (ifl->ifl_flags & FLG_IF_HSTRTAB) {
2051 ndx = shdr->sh_link;
2052 if ((ndx == 0) || (ndx >= ifl->ifl_shnum)) {
2053 ld_eprintf(ofl, ERR_FATAL,
2054 MSG_INTL(MSG_FIL_INVSHLINK), ifl->ifl_name,
2055 EC_WORD(symsecndx), symsecname, EC_XWORD(ndx));
2056 return (S_ERROR);
2057 }
2058 strsize = ifl->ifl_isdesc[ndx]->is_shdr->sh_size;
2059 strs = ifl->ifl_isdesc[ndx]->is_indata->d_buf;
2060 if (ifl->ifl_isdesc[ndx]->is_name)
2061 strsecname = ifl->ifl_isdesc[ndx]->is_name;
2062 else
2063 strsecname = MSG_ORIG(MSG_STR_EMPTY);
2064 } else {
2065 /*
2066 * There is no string table section in this input file
2067 * although there are symbols in this symbol table section.
2068 * This means that these symbols do not have names.
2069 * Currently, only scratch register symbols are allowed
2070 * not to have names.
2071 */
2072 strsize = 0;
2073 strs = (char *)MSG_ORIG(MSG_STR_EMPTY);
2074 strsecname = MSG_ORIG(MSG_STR_EMPTY);
2075 }
2076
2077 /*
2078 * Determine the number of local symbols together with the total
2079 * number we have to process.
2080 */
2081 total = (Word)(shdr->sh_size / shdr->sh_entsize);
2082 local = shdr->sh_info;
2083
2084 /*
2085 * Allocate a symbol table index array and a local symbol array
2086 * (global symbols are processed and added to the ofl->ofl_symbkt[]
2087 * array). If we are dealing with a relocatable object, allocate the
2088 * local symbol descriptors. If this isn't a relocatable object we
2089 * still have to process any shared object locals to determine if any
2090 * register symbols exist. Although these aren't added to the output
2091 * image, they are used as part of symbol resolution.
2092 */
2093 if ((ifl->ifl_oldndx = libld_malloc((size_t)(total *
2094 sizeof (Sym_desc *)))) == NULL)
2095 return (S_ERROR);
2096 etype_rel = (etype == ET_REL);
2097 if (etype_rel && local) {
2098 if ((ifl->ifl_locs =
2099 libld_calloc(sizeof (Sym_desc), local)) == NULL)
2100 return (S_ERROR);
2101 /* LINTED */
2102 ifl->ifl_locscnt = (Word)local;
2103 }
2104 ifl->ifl_symscnt = total;
2105
2106 /*
2107 * If there are local symbols to save add them to the symbol table
2108 * index array.
2109 */
2110 if (local) {
2111 int allow_ldynsym = OFL_ALLOW_LDYNSYM(ofl);
2112 Sym_desc *last_file_sdp = NULL;
2113 int last_file_ndx = 0;
2114
2115 for (sym++, ndx = 1; ndx < local; sym++, ndx++) {
2116 sd_flag_t sdflags = FLG_SY_CLEAN;
2117 Word shndx;
2118 const char *name;
2119 Sym_desc *rsdp;
2120 int shndx_bad = 0;
2121 int symtab_enter = 1;
2122
2123 /*
2124 * Determine and validate the associated section index.
2125 */
2126 if (symshndx && (sym->st_shndx == SHN_XINDEX)) {
2127 shndx = symshndx[ndx];
2128 } else if ((shndx = sym->st_shndx) >= SHN_LORESERVE) {
2129 sdflags |= FLG_SY_SPECSEC;
2130 } else if (shndx > ifl->ifl_shnum) {
2131 /* We need the name before we can issue error */
2132 shndx_bad = 1;
2133 }
2134
2135 /*
2136 * Check if st_name has a valid value or not.
2137 */
2138 if ((name = string(ofl, ifl, sym, strs, strsize, ndx,
2139 shndx, symsecndx, symsecname, strsecname,
2140 &sdflags)) == NULL)
2141 continue;
2142
2143 /*
2144 * Now that we have the name, if the section index
2145 * was bad, report it.
2146 */
2147 if (shndx_bad) {
2148 ld_eprintf(ofl, ERR_WARNING,
2149 MSG_INTL(MSG_SYM_INVSHNDX),
2150 demangle_symname(name, symsecname, ndx),
2151 ifl->ifl_name,
2152 conv_sym_shndx(osabi, mach, sym->st_shndx,
2153 CONV_FMT_DECIMAL, &inv_buf));
2154 continue;
2155 }
2156
2157 /*
2158 * If this local symbol table originates from a shared
2159 * object, then we're only interested in recording
2160 * register symbols. As local symbol descriptors aren't
2161 * allocated for shared objects, one will be allocated
2162 * to associated with the register symbol. This symbol
2163 * won't become part of the output image, but we must
2164 * process it to test for register conflicts.
2165 */
2166 rsdp = sdp = NULL;
2167 if (sdflags & FLG_SY_REGSYM) {
2168 /*
2169 * The presence of FLG_SY_REGSYM means that
2170 * the pointers in ld_targ.t_ms are non-NULL.
2171 */
2172 rsdp = (*ld_targ.t_ms.ms_reg_find)(sym, ofl);
2173 if (rsdp != 0) {
2174 /*
2175 * The fact that another register def-
2176 * inition has been found is fatal.
2177 * Call the verification routine to get
2178 * the error message and move on.
2179 */
2180 (void) (*ld_targ.t_ms.ms_reg_check)
2181 (rsdp, sym, name, ifl, ofl);
2182 continue;
2183 }
2184
2185 if (etype == ET_DYN) {
2186 if ((sdp = libld_calloc(
2187 sizeof (Sym_desc), 1)) == NULL)
2188 return (S_ERROR);
2189 sdp->sd_ref = REF_DYN_SEEN;
2190
2191 /* Will not appear in output object */
2192 symtab_enter = 0;
2193 }
2194 } else if (etype == ET_DYN)
2195 continue;
2196
2197 /*
2198 * Fill in the remaining symbol descriptor information.
2199 */
2200 if (sdp == NULL) {
2201 sdp = &(ifl->ifl_locs[ndx]);
2202 sdp->sd_ref = REF_REL_NEED;
2203 sdp->sd_symndx = ndx;
2204 }
2205 if (rsdp == NULL) {
2206 sdp->sd_name = name;
2207 sdp->sd_sym = sym;
2208 sdp->sd_shndx = shndx;
2209 sdp->sd_flags = sdflags;
2210 sdp->sd_file = ifl;
2211 ifl->ifl_oldndx[ndx] = sdp;
2212 }
2213
2214 DBG_CALL(Dbg_syms_entry(ofl->ofl_lml, ndx, sdp));
2215
2216 /*
2217 * Reclassify any SHN_SUNW_IGNORE symbols to SHN_UNDEF
2218 * so as to simplify future processing.
2219 */
2220 if (sym->st_shndx == SHN_SUNW_IGNORE) {
2221 sdp->sd_shndx = shndx = SHN_UNDEF;
2222 sdp->sd_flags |= (FLG_SY_IGNORE | FLG_SY_ELIM);
2223 }
2224
2225 /*
2226 * Process any register symbols.
2227 */
2228 if (sdp->sd_flags & FLG_SY_REGSYM) {
2229 /*
2230 * Add a diagnostic to indicate we've caught a
2231 * register symbol, as this can be useful if a
2232 * register conflict is later discovered.
2233 */
2234 DBG_CALL(Dbg_syms_entered(ofl, sym, sdp));
2235
2236 /*
2237 * If this register symbol hasn't already been
2238 * recorded, enter it now.
2239 *
2240 * The presence of FLG_SY_REGSYM means that
2241 * the pointers in ld_targ.t_ms are non-NULL.
2242 */
2243 if ((rsdp == NULL) &&
2244 ((*ld_targ.t_ms.ms_reg_enter)(sdp, ofl) ==
2245 0))
2246 return (S_ERROR);
2247 }
2248
2249 /*
2250 * Assign an input section.
2251 */
2252 if ((sym->st_shndx != SHN_UNDEF) &&
2253 ((sdp->sd_flags & FLG_SY_SPECSEC) == 0))
2254 sdp->sd_isc = ifl->ifl_isdesc[shndx];
2255
2256 /*
2257 * If this symbol falls within the range of a section
2258 * being discarded, then discard the symbol itself.
2259 * There is no reason to keep this local symbol.
2260 */
2261 if (sdp->sd_isc &&
2262 (sdp->sd_isc->is_flags & FLG_IS_DISCARD)) {
2263 sdp->sd_flags |= FLG_SY_ISDISC;
2264 DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
2265 continue;
2266 }
2267
2268 /*
2269 * Skip any section symbols as new versions of these
2270 * will be created.
2271 */
2272 if ((type = ELF_ST_TYPE(sym->st_info)) == STT_SECTION) {
2273 if (sym->st_shndx == SHN_UNDEF) {
2274 ld_eprintf(ofl, ERR_WARNING,
2275 MSG_INTL(MSG_SYM_INVSHNDX),
2276 demangle_symname(name, symsecname,
2277 ndx), ifl->ifl_name,
2278 conv_sym_shndx(osabi, mach,
2279 sym->st_shndx, CONV_FMT_DECIMAL,
2280 &inv_buf));
2281 }
2282 continue;
2283 }
2284
2285 /*
2286 * For a relocatable object, if this symbol is defined
2287 * and has non-zero length and references an address
2288 * within an associated section, then check its extents
2289 * to make sure the section boundaries encompass it.
2290 * If they don't, the ELF file is corrupt.
2291 */
2292 if (etype_rel) {
2293 if (SYM_LOC_BADADDR(sdp, sym, type)) {
2294 issue_badaddr_msg(ifl, ofl, sdp,
2295 sym, shndx);
2296 if (ofl->ofl_flags & FLG_OF_FATAL)
2297 continue;
2298 }
2299
2300 /*
2301 * We have observed relocatable objects
2302 * containing identical adjacent STT_FILE
2303 * symbols. Discard any other than the first,
2304 * as they are all equivalent and the extras
2305 * do not add information.
2306 *
2307 * For the purpose of this test, we assume
2308 * that only the symbol type and the string
2309 * table offset (st_name) matter.
2310 */
2311 if (type == STT_FILE) {
2312 int toss = (last_file_sdp != NULL) &&
2313 ((ndx - 1) == last_file_ndx) &&
2314 (sym->st_name ==
2315 last_file_sdp->sd_sym->st_name);
2316
2317 last_file_sdp = sdp;
2318 last_file_ndx = ndx;
2319 if (toss) {
2320 sdp->sd_flags |= FLG_SY_INVALID;
2321 DBG_CALL(Dbg_syms_dup_discarded(
2322 ofl->ofl_lml, ndx, sdp));
2323 continue;
2324 }
2325 }
2326 }
2327
2328
2329 /*
2330 * Sanity check for TLS
2331 */
2332 if ((sym->st_size != 0) && ((type == STT_TLS) &&
2333 (sym->st_shndx != SHN_COMMON))) {
2334 Is_desc *isp = sdp->sd_isc;
2335
2336 if ((isp == NULL) || (isp->is_shdr == NULL) ||
2337 ((isp->is_shdr->sh_flags & SHF_TLS) == 0)) {
2338 ld_eprintf(ofl, ERR_FATAL,
2339 MSG_INTL(MSG_SYM_TLS),
2340 demangle(sdp->sd_name),
2341 ifl->ifl_name);
2342 continue;
2343 }
2344 }
2345
2346 /*
2347 * Carry our some basic sanity checks (these are just
2348 * some of the erroneous symbol entries we've come
2349 * across, there's probably a lot more). The symbol
2350 * will not be carried forward to the output file, which
2351 * won't be a problem unless a relocation is required
2352 * against it.
2353 */
2354 if (((sdp->sd_flags & FLG_SY_SPECSEC) &&
2355 ((sym->st_shndx == SHN_COMMON)) ||
2356 ((type == STT_FILE) &&
2357 (sym->st_shndx != SHN_ABS))) ||
2358 (sdp->sd_isc && (sdp->sd_isc->is_osdesc == NULL))) {
2359 ld_eprintf(ofl, ERR_WARNING,
2360 MSG_INTL(MSG_SYM_INVSHNDX),
2361 demangle_symname(name, symsecname, ndx),
2362 ifl->ifl_name,
2363 conv_sym_shndx(osabi, mach, sym->st_shndx,
2364 CONV_FMT_DECIMAL, &inv_buf));
2365 sdp->sd_isc = NULL;
2366 sdp->sd_flags |= FLG_SY_INVALID;
2367 continue;
2368 }
2369
2370 /*
2371 * As these local symbols will become part of the output
2372 * image, record their number and name string size.
2373 * Globals are counted after all input file processing
2374 * (and hence symbol resolution) is complete during
2375 * sym_validate().
2376 */
2377 if (!(ofl->ofl_flags & FLG_OF_REDLSYM) &&
2378 symtab_enter) {
2379 ofl->ofl_locscnt++;
2380
2381 if ((((sdp->sd_flags & FLG_SY_REGSYM) == 0) ||
2382 sym->st_name) && (st_insert(ofl->ofl_strtab,
2383 sdp->sd_name) == -1))
2384 return (S_ERROR);
2385
2386 if (allow_ldynsym && sym->st_name &&
2387 ldynsym_symtype[type]) {
2388 ofl->ofl_dynlocscnt++;
2389 if (st_insert(ofl->ofl_dynstrtab,
2390 sdp->sd_name) == -1)
2391 return (S_ERROR);
2392 /* Include it in sort section? */
2393 DYNSORT_COUNT(sdp, sym, type, ++);
2394 }
2395 }
2396 }
2397 }
2398
2399 /*
2400 * The GNU ld interprets the top bit of the 16-bit Versym value
2401 * (0x8000) as the "hidden" bit. If this bit is set, the linker
2402 * is supposed to act as if that symbol does not exist. The Solaris
2403 * linker does not support this mechanism, or the model of interface
2404 * evolution that it allows, but we honor it in GNU ld produced
2405 * objects in order to interoperate with them.
2406 *
2407 * Determine if we should honor the GNU hidden bit for this file.
2408 */
2409 test_gnu_hidden_bit = ((ifl->ifl_flags & FLG_IF_GNUVER) != 0) &&
2410 (ifl->ifl_versym != NULL);
2411
2412 /*
2413 * Determine whether object capabilities for this file are being
2414 * converted into symbol capabilities. If so, global function symbols,
2415 * and initialized global data symbols, need special translation and
2416 * processing.
2417 */
2418 if ((etype == ET_REL) && (ifl->ifl_flags & FLG_IF_OTOSCAP))
2419 cdp = ifl->ifl_caps;
2420
2421 /*
2422 * Now scan the global symbols entering them in the internal symbol
2423 * table or resolving them as necessary.
2424 */
2425 sym = (Sym *)isc->is_indata->d_buf;
2426 sym += local;
2427 weak = 0;
2428 /* LINTED */
2429 for (ndx = (int)local; ndx < total; sym++, ndx++) {
2430 const char *name;
2431 sd_flag_t sdflags = 0;
2432 Word shndx;
2433 int shndx_bad = 0;
2434 Sym *nsym = sym;
2435 Cap_pair *cpp = NULL;
2436 uchar_t ntype;
2437
2438 /*
2439 * Determine and validate the associated section index.
2440 */
2441 if (symshndx && (nsym->st_shndx == SHN_XINDEX)) {
2442 shndx = symshndx[ndx];
2443 } else if ((shndx = nsym->st_shndx) >= SHN_LORESERVE) {
2444 sdflags |= FLG_SY_SPECSEC;
2445 } else if (shndx > ifl->ifl_shnum) {
2446 /* We need the name before we can issue error */
2447 shndx_bad = 1;
2448 }
2449
2450 /*
2451 * Check if st_name has a valid value or not.
2452 */
2453 if ((name = string(ofl, ifl, nsym, strs, strsize, ndx, shndx,
2454 symsecndx, symsecname, strsecname, &sdflags)) == NULL)
2455 continue;
2456
2457 /*
2458 * Now that we have the name, report an erroneous section index.
2459 */
2460 if (shndx_bad) {
2461 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_INVSHNDX),
2462 demangle_symname(name, symsecname, ndx),
2463 ifl->ifl_name,
2464 conv_sym_shndx(osabi, mach, nsym->st_shndx,
2465 CONV_FMT_DECIMAL, &inv_buf));
2466 continue;
2467 }
2468
2469 /*
2470 * Test for the GNU hidden bit, and ignore symbols that
2471 * have it set.
2472 */
2473 if (test_gnu_hidden_bit &&
2474 ((ifl->ifl_versym[ndx] & 0x8000) != 0))
2475 continue;
2476
2477 /*
2478 * The linker itself will generate symbols for _end, _etext,
2479 * _edata, _DYNAMIC and _PROCEDURE_LINKAGE_TABLE_, so don't
2480 * bother entering these symbols from shared objects. This
2481 * results in some wasted resolution processing, which is hard
2482 * to feel, but if nothing else, pollutes diagnostic relocation
2483 * output.
2484 */
2485 if (name[0] && (etype == ET_DYN) && (nsym->st_size == 0) &&
2486 (ELF_ST_TYPE(nsym->st_info) == STT_OBJECT) &&
2487 (name[0] == '_') && ((name[1] == 'e') ||
2488 (name[1] == 'D') || (name[1] == 'P')) &&
2489 ((strcmp(name, MSG_ORIG(MSG_SYM_ETEXT_U)) == 0) ||
2490 (strcmp(name, MSG_ORIG(MSG_SYM_EDATA_U)) == 0) ||
2491 (strcmp(name, MSG_ORIG(MSG_SYM_END_U)) == 0) ||
2492 (strcmp(name, MSG_ORIG(MSG_SYM_DYNAMIC_U)) == 0) ||
2493 (strcmp(name, MSG_ORIG(MSG_SYM_PLKTBL_U)) == 0))) {
2494 ifl->ifl_oldndx[ndx] = 0;
2495 continue;
2496 }
2497
2498 /*
2499 * The '-z wrap=XXX' option emulates the GNU ld --wrap=XXX
2500 * option. When XXX is the symbol to be wrapped:
2501 *
2502 * - An undefined reference to XXX is converted to __wrap_XXX
2503 * - An undefined reference to __real_XXX is converted to XXX
2504 *
2505 * The idea is that the user can supply a wrapper function
2506 * __wrap_XXX that does some work, and then uses the name
2507 * __real_XXX to pass the call on to the real function. The
2508 * wrapper objects are linked with the original unmodified
2509 * objects to produce a wrapped version of the output object.
2510 */
2511 if (ofl->ofl_wrap && name[0] && (shndx == SHN_UNDEF)) {
2512 WrapSymNode wsn, *wsnp;
2513
2514 /*
2515 * If this is the __real_XXX form, advance the
2516 * pointer to reference the wrapped name.
2517 */
2518 wsn.wsn_name = name;
2519 if ((*name == '_') &&
2520 (strncmp(name, MSG_ORIG(MSG_STR_UU_REAL_U),
2521 MSG_STR_UU_REAL_U_SIZE) == 0))
2522 wsn.wsn_name += MSG_STR_UU_REAL_U_SIZE;
2523
2524 /*
2525 * Is this symbol in the wrap AVL tree? If so, map
2526 * XXX to __wrap_XXX, and __real_XXX to XXX. Note that
2527 * wsn.wsn_name will equal the current value of name
2528 * if the __real_ prefix is not present.
2529 */
2530 if ((wsnp = avl_find(ofl->ofl_wrap, &wsn, 0)) != NULL) {
2531 const char *old_name = name;
2532
2533 name = (wsn.wsn_name == name) ?
2534 wsnp->wsn_wrapname : wsn.wsn_name;
2535 DBG_CALL(Dbg_syms_wrap(ofl->ofl_lml, ndx,
2536 old_name, name));
2537 }
2538 }
2539
2540 /*
2541 * Determine and validate the symbols binding.
2542 */
2543 bind = ELF_ST_BIND(nsym->st_info);
2544 if ((bind != STB_GLOBAL) && (bind != STB_WEAK)) {
2545 ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_SYM_NONGLOB),
2546 demangle_symname(name, symsecname, ndx),
2547 ifl->ifl_name,
2548 conv_sym_info_bind(bind, 0, &inv_buf));
2549 continue;
2550 }
2551 if (bind == STB_WEAK)
2552 weak++;
2553
2554 /*
2555 * If this symbol falls within the range of a section being
2556 * discarded, then discard the symbol itself.
2557 */
2558 if (((sdflags & FLG_SY_SPECSEC) == 0) &&
2559 (nsym->st_shndx != SHN_UNDEF)) {
2560 Is_desc *isp;
2561
2562 if (shndx >= ifl->ifl_shnum) {
2563 /*
2564 * Carry our some basic sanity checks
2565 * The symbol will not be carried forward to
2566 * the output file, which won't be a problem
2567 * unless a relocation is required against it.
2568 */
2569 ld_eprintf(ofl, ERR_WARNING,
2570 MSG_INTL(MSG_SYM_INVSHNDX),
2571 demangle_symname(name, symsecname, ndx),
2572 ifl->ifl_name,
2573 conv_sym_shndx(osabi, mach, nsym->st_shndx,
2574 CONV_FMT_DECIMAL, &inv_buf));
2575 continue;
2576 }
2577
2578 isp = ifl->ifl_isdesc[shndx];
2579 if (isp && (isp->is_flags & FLG_IS_DISCARD)) {
2580 if ((sdp =
2581 libld_calloc(sizeof (Sym_desc), 1)) == NULL)
2582 return (S_ERROR);
2583
2584 /*
2585 * Create a dummy symbol entry so that if we
2586 * find any references to this discarded symbol
2587 * we can compensate.
2588 */
2589 sdp->sd_name = name;
2590 sdp->sd_sym = nsym;
2591 sdp->sd_file = ifl;
2592 sdp->sd_isc = isp;
2593 sdp->sd_flags = FLG_SY_ISDISC;
2594 ifl->ifl_oldndx[ndx] = sdp;
2595
2596 DBG_CALL(Dbg_syms_discarded(ofl->ofl_lml, sdp));
2597 continue;
2598 }
2599 }
2600
2601 /*
2602 * If object capabilities for this file are being converted
2603 * into symbol capabilities, then:
2604 *
2605 * - Any global function, or initialized global data symbol
2606 * definitions (ie., those that are not associated with
2607 * special symbol types, ie., ABS, COMMON, etc.), and which
2608 * have not been reduced to locals, are converted to symbol
2609 * references (UNDEF). This ensures that any reference to
2610 * the original symbol, for example from a relocation, get
2611 * associated to a capabilities family lead symbol, ie., a
2612 * generic instance.
2613 *
2614 * - For each global function, or object symbol definition,
2615 * a new local symbol is created. The function or object
2616 * is renamed using the capabilities CA_SUNW_ID definition
2617 * (which might have been fabricated for this purpose -
2618 * see get_cap_group()). The new symbol name is:
2619 *
2620 * <original name>%<capability group identifier>
2621 *
2622 * This symbol is associated to the same location, and
2623 * becomes a capabilities family member.
2624 */
2625 /* LINTED */
2626 hash = (Word)elf_hash(name);
2627
2628 ntype = ELF_ST_TYPE(nsym->st_info);
2629 if (cdp && (nsym->st_shndx != SHN_UNDEF) &&
2630 ((sdflags & FLG_SY_SPECSEC) == 0) &&
2631 ((ntype == STT_FUNC) || (ntype == STT_OBJECT))) {
2632 /*
2633 * Determine this symbol's visibility. If a mapfile has
2634 * indicated this symbol should be local, then there's
2635 * no point in transforming this global symbol to a
2636 * capabilities symbol. Otherwise, create a symbol
2637 * capability pair descriptor to record this symbol as
2638 * a candidate for translation.
2639 */
2640 if (sym_cap_vis(name, hash, sym, ofl) &&
2641 ((cpp = alist_append(&cappairs, NULL,
2642 sizeof (Cap_pair), AL_CNT_CAP_PAIRS)) == NULL))
2643 return (S_ERROR);
2644 }
2645
2646 if (cpp) {
2647 Sym *rsym;
2648
2649 DBG_CALL(Dbg_syms_cap_convert(ofl, ndx, name, nsym));
2650
2651 /*
2652 * Allocate a new symbol descriptor to represent the
2653 * transformed global symbol. The descriptor points
2654 * to the original symbol information (which might
2655 * indicate a global or weak visibility). The symbol
2656 * information will be transformed into a local symbol
2657 * later, after any weak aliases are culled.
2658 */
2659 if ((cpp->c_osdp =
2660 libld_malloc(sizeof (Sym_desc))) == NULL)
2661 return (S_ERROR);
2662
2663 cpp->c_osdp->sd_name = name;
2664 cpp->c_osdp->sd_sym = nsym;
2665 cpp->c_osdp->sd_shndx = shndx;
2666 cpp->c_osdp->sd_file = ifl;
2667 cpp->c_osdp->sd_isc = ifl->ifl_isdesc[shndx];
2668 cpp->c_osdp->sd_ref = REF_REL_NEED;
2669
2670 /*
2671 * Save the capabilities group this symbol belongs to,
2672 * and the original symbol index.
2673 */
2674 cpp->c_group = cdp->ca_groups->apl_data[0];
2675 cpp->c_ndx = ndx;
2676
2677 /*
2678 * Replace the original symbol definition with a symbol
2679 * reference. Make sure this reference isn't left as a
2680 * weak.
2681 */
2682 if ((rsym = libld_malloc(sizeof (Sym))) == NULL)
2683 return (S_ERROR);
2684
2685 *rsym = *nsym;
2686
2687 rsym->st_info = ELF_ST_INFO(STB_GLOBAL, ntype);
2688 rsym->st_shndx = shndx = SHN_UNDEF;
2689 rsym->st_value = 0;
2690 rsym->st_size = 0;
2691
2692 sdflags |= FLG_SY_CAP;
2693
2694 nsym = rsym;
2695 }
2696
2697 /*
2698 * If the symbol does not already exist in the internal symbol
2699 * table add it, otherwise resolve the conflict. If the symbol
2700 * from this file is kept, retain its symbol table index for
2701 * possible use in associating a global alias.
2702 */
2703 if ((sdp = ld_sym_find(name, hash, &where, ofl)) == NULL) {
2704 DBG_CALL(Dbg_syms_global(ofl->ofl_lml, ndx, name));
2705 if ((sdp = ld_sym_enter(name, nsym, hash, ifl, ofl, ndx,
2706 shndx, sdflags, &where)) == (Sym_desc *)S_ERROR)
2707 return (S_ERROR);
2708
2709 } else if (ld_sym_resolve(sdp, nsym, ifl, ofl, ndx, shndx,
2710 sdflags) == S_ERROR)
2711 return (S_ERROR);
2712
2713 /*
2714 * Now that we have a symbol descriptor, retain the descriptor
2715 * for later use by symbol capabilities processing.
2716 */
2717 if (cpp)
2718 cpp->c_nsdp = sdp;
2719
2720 /*
2721 * After we've compared a defined symbol in one shared
2722 * object, flag the symbol so we don't compare it again.
2723 */
2724 if ((etype == ET_DYN) && (nsym->st_shndx != SHN_UNDEF) &&
2725 ((sdp->sd_flags & FLG_SY_SOFOUND) == 0))
2726 sdp->sd_flags |= FLG_SY_SOFOUND;
2727
2728 /*
2729 * If the symbol is accepted from this file retain the symbol
2730 * index for possible use in aliasing.
2731 */
2732 if (sdp->sd_file == ifl)
2733 sdp->sd_symndx = ndx;
2734
2735 ifl->ifl_oldndx[ndx] = sdp;
2736
2737 /*
2738 * If we've accepted a register symbol, continue to validate
2739 * it.
2740 */
2741 if (sdp->sd_flags & FLG_SY_REGSYM) {
2742 Sym_desc *rsdp;
2743
2744 /*
2745 * The presence of FLG_SY_REGSYM means that
2746 * the pointers in ld_targ.t_ms are non-NULL.
2747 */
2748 rsdp = (*ld_targ.t_ms.ms_reg_find)(sdp->sd_sym, ofl);
2749 if (rsdp == NULL) {
2750 if ((*ld_targ.t_ms.ms_reg_enter)(sdp, ofl) == 0)
2751 return (S_ERROR);
2752 } else if (rsdp != sdp) {
2753 (void) (*ld_targ.t_ms.ms_reg_check)(rsdp,
2754 sdp->sd_sym, sdp->sd_name, ifl, ofl);
2755 }
2756 }
2757
2758 /*
2759 * For a relocatable object, if this symbol is defined
2760 * and has non-zero length and references an address
2761 * within an associated section, then check its extents
2762 * to make sure the section boundaries encompass it.
2763 * If they don't, the ELF file is corrupt. Note that this
2764 * global symbol may have come from another file to satisfy
2765 * an UNDEF symbol of the same name from this one. In that
2766 * case, we don't check it, because it was already checked
2767 * as part of its own file.
2768 */
2769 if (etype_rel && (sdp->sd_file == ifl)) {
2770 Sym *tsym = sdp->sd_sym;
2771
2772 if (SYM_LOC_BADADDR(sdp, tsym,
2773 ELF_ST_TYPE(tsym->st_info))) {
2774 issue_badaddr_msg(ifl, ofl, sdp,
2775 tsym, tsym->st_shndx);
2776 continue;
2777 }
2778 }
2779 }
2780 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
2781
2782 /*
2783 * Associate weak (alias) symbols to their non-weak counterparts by
2784 * scanning the global symbols one more time.
2785 *
2786 * This association is needed when processing the symbols from a shared
2787 * object dependency when a a weak definition satisfies a reference:
2788 *
2789 * - When building a dynamic executable, if a referenced symbol is a
2790 * data item, the symbol data is copied to the executables address
2791 * space. In this copy-relocation case, we must also reassociate
2792 * the alias symbol with its new location in the executable.
2793 *
2794 * - If the referenced symbol is a function then we may need to
2795 * promote the symbols binding from undefined weak to undefined,
2796 * otherwise the run-time linker will not generate the correct
2797 * relocation error should the symbol not be found.
2798 *
2799 * Weak alias association is also required when a local dynsym table
2800 * is being created. This table should only contain one instance of a
2801 * symbol that is associated to a given address.
2802 *
2803 * The true association between a weak/strong symbol pair is that both
2804 * symbol entries are identical, thus first we create a sorted symbol
2805 * list keyed off of the symbols section index and value. If the symbol
2806 * belongs to the same section and has the same value, then the chances
2807 * are that the rest of the symbols data is the same. This list is then
2808 * scanned for weak symbols, and if one is found then any strong
2809 * association will exist in the entries that follow. Thus we just have
2810 * to scan one (typically a single alias) or more (in the uncommon
2811 * instance of multiple weak to strong associations) entries to
2812 * determine if a match exists.
2813 */
2814 if (weak && (OFL_ALLOW_LDYNSYM(ofl) || (etype == ET_DYN)) &&
2815 (total > local)) {
2816 static Sym_desc **sort;
2817 static size_t osize = 0;
2818 size_t nsize = (total - local) * sizeof (Sym_desc *);
2819
2820 /*
2821 * As we might be processing many input files, and many symbols,
2822 * try and reuse a static sort buffer. Note, presently we're
2823 * playing the game of never freeing any buffers as there's a
2824 * belief this wastes time.
2825 */
2826 if ((osize == 0) || (nsize > osize)) {
2827 if ((sort = libld_malloc(nsize)) == NULL)
2828 return (S_ERROR);
2829 osize = nsize;
2830 }
2831 (void) memcpy((void *)sort, &ifl->ifl_oldndx[local], nsize);
2832
2833 qsort(sort, (total - local), sizeof (Sym_desc *), compare);
2834
2835 for (ndx = 0; ndx < (total - local); ndx++) {
2836 Sym_desc *wsdp = sort[ndx];
2837 Sym *wsym;
2838 int sndx;
2839
2840 /*
2841 * Ignore any empty symbol descriptor, or the case where
2842 * the symbol has been resolved to a different file.
2843 */
2844 if ((wsdp == NULL) || (wsdp->sd_file != ifl))
2845 continue;
2846
2847 wsym = wsdp->sd_sym;
2848
2849 if ((wsym->st_shndx == SHN_UNDEF) ||
2850 (wsdp->sd_flags & FLG_SY_SPECSEC) ||
2851 (ELF_ST_BIND(wsym->st_info) != STB_WEAK))
2852 continue;
2853
2854 /*
2855 * We have a weak symbol, if it has a strong alias it
2856 * will have been sorted to one of the following sort
2857 * table entries. Note that we could have multiple weak
2858 * symbols aliased to one strong (if this occurs then
2859 * the strong symbol only maintains one alias back to
2860 * the last weak).
2861 */
2862 for (sndx = ndx + 1; sndx < (total - local); sndx++) {
2863 Sym_desc *ssdp = sort[sndx];
2864 Sym *ssym;
2865 sd_flag_t w_dynbits, s_dynbits;
2866
2867 /*
2868 * Ignore any empty symbol descriptor, or the
2869 * case where the symbol has been resolved to a
2870 * different file.
2871 */
2872 if ((ssdp == NULL) || (ssdp->sd_file != ifl))
2873 continue;
2874
2875 ssym = ssdp->sd_sym;
2876
2877 if (ssym->st_shndx == SHN_UNDEF)
2878 continue;
2879
2880 if ((ssym->st_shndx != wsym->st_shndx) ||
2881 (ssym->st_value != wsym->st_value))
2882 break;
2883
2884 if ((ssym->st_size != wsym->st_size) ||
2885 (ssdp->sd_flags & FLG_SY_SPECSEC) ||
2886 (ELF_ST_BIND(ssym->st_info) == STB_WEAK))
2887 continue;
2888
2889 /*
2890 * If a sharable object, set link fields so
2891 * that they reference each other.`
2892 */
2893 if (etype == ET_DYN) {
2894 ssdp->sd_aux->sa_linkndx =
2895 (Word)wsdp->sd_symndx;
2896 wsdp->sd_aux->sa_linkndx =
2897 (Word)ssdp->sd_symndx;
2898 }
2899
2900 /*
2901 * Determine which of these two symbols go into
2902 * the sort section. If a mapfile has made
2903 * explicit settings of the FLG_SY_*DYNSORT
2904 * flags for both symbols, then we do what they
2905 * say. If one has the DYNSORT flags set, we
2906 * set the NODYNSORT bit in the other. And if
2907 * neither has an explicit setting, then we
2908 * favor the weak symbol because they usually
2909 * lack the leading underscore.
2910 */
2911 w_dynbits = wsdp->sd_flags &
2912 (FLG_SY_DYNSORT | FLG_SY_NODYNSORT);
2913 s_dynbits = ssdp->sd_flags &
2914 (FLG_SY_DYNSORT | FLG_SY_NODYNSORT);
2915 if (!(w_dynbits && s_dynbits)) {
2916 if (s_dynbits) {
2917 if (s_dynbits == FLG_SY_DYNSORT)
2918 wsdp->sd_flags |=
2919 FLG_SY_NODYNSORT;
2920 } else if (w_dynbits !=
2921 FLG_SY_NODYNSORT) {
2922 ssdp->sd_flags |=
2923 FLG_SY_NODYNSORT;
2924 }
2925 }
2926 break;
2927 }
2928 }
2929 }
2930
2931 /*
2932 * Having processed all symbols, under -z symbolcap, reprocess any
2933 * symbols that are being translated from global to locals. The symbol
2934 * pair that has been collected defines the original symbol (c_osdp),
2935 * which will become a local, and the new symbol (c_nsdp), which will
2936 * become a reference (UNDEF) for the original.
2937 *
2938 * Scan these symbol pairs looking for weak symbols, which have non-weak
2939 * aliases. There is no need to translate both of these symbols to
2940 * locals, only the global is necessary.
2941 */
2942 if (cappairs) {
2943 Aliste idx1;
2944 Cap_pair *cpp1;
2945
2946 for (ALIST_TRAVERSE(cappairs, idx1, cpp1)) {
2947 Sym_desc *sdp1 = cpp1->c_osdp;
2948 Sym *sym1 = sdp1->sd_sym;
2949 uchar_t bind1 = ELF_ST_BIND(sym1->st_info);
2950 Aliste idx2;
2951 Cap_pair *cpp2;
2952
2953 /*
2954 * If this symbol isn't weak, it's capability member is
2955 * retained for the creation of a local symbol.
2956 */
2957 if (bind1 != STB_WEAK)
2958 continue;
2959
2960 /*
2961 * If this is a weak symbol, traverse the capabilities
2962 * list again to determine if a corresponding non-weak
2963 * symbol exists.
2964 */
2965 for (ALIST_TRAVERSE(cappairs, idx2, cpp2)) {
2966 Sym_desc *sdp2 = cpp2->c_osdp;
2967 Sym *sym2 = sdp2->sd_sym;
2968 uchar_t bind2 =
2969 ELF_ST_BIND(sym2->st_info);
2970
2971 if ((cpp1 == cpp2) ||
2972 (cpp1->c_group != cpp2->c_group) ||
2973 (sym1->st_value != sym2->st_value) ||
2974 (bind2 == STB_WEAK))
2975 continue;
2976
2977 /*
2978 * The weak symbol (sym1) has a non-weak (sym2)
2979 * counterpart. There's no point in translating
2980 * both of these equivalent symbols to locals.
2981 * Add this symbol capability alias to the
2982 * capabilities family information, and remove
2983 * the weak symbol.
2984 */
2985 if (ld_cap_add_family(ofl, cpp2->c_nsdp,
2986 cpp1->c_nsdp, NULL, NULL) == S_ERROR)
2987 return (S_ERROR);
2988
2989 free((void *)cpp1->c_osdp);
2990 (void) alist_delete(cappairs, &idx1);
2991 }
2992 }
2993
2994 DBG_CALL(Dbg_util_nl(ofl->ofl_lml, DBG_NL_STD));
2995
2996 /*
2997 * The capability pairs information now represents all the
2998 * global symbols that need transforming to locals. These
2999 * local symbols are renamed using their group identifiers.
3000 */
3001 for (ALIST_TRAVERSE(cappairs, idx1, cpp1)) {
3002 Sym_desc *osdp = cpp1->c_osdp;
3003 Objcapset *capset;
3004 size_t nsize, tsize;
3005 const char *oname;
3006 char *cname, *idstr;
3007 Sym *csym;
3008
3009 /*
3010 * If the local symbol has not yet been translated
3011 * convert it to a local symbol with a name.
3012 */
3013 if ((osdp->sd_flags & FLG_SY_CAP) != 0)
3014 continue;
3015
3016 /*
3017 * As we're converting object capabilities to symbol
3018 * capabilities, obtain the capabilities set for this
3019 * object, so as to retrieve the CA_SUNW_ID value.
3020 */
3021 capset = &cpp1->c_group->cg_set;
3022
3023 /*
3024 * Create a new name from the existing symbol and the
3025 * capabilities group identifier. Note, the delimiter
3026 * between the symbol name and identifier name is hard-
3027 * coded here (%), so that we establish a convention
3028 * for transformed symbol names.
3029 */
3030 oname = osdp->sd_name;
3031
3032 idstr = capset->oc_id.cs_str;
3033 nsize = strlen(oname);
3034 tsize = nsize + 1 + strlen(idstr) + 1;
3035 if ((cname = libld_malloc(tsize)) == 0)
3036 return (S_ERROR);
3037
3038 (void) strcpy(cname, oname);
3039 cname[nsize++] = '%';
3040 (void) strcpy(&cname[nsize], idstr);
3041
3042 /*
3043 * Allocate a new symbol table entry, transform this
3044 * symbol to a local, and assign the new name.
3045 */
3046 if ((csym = libld_malloc(sizeof (Sym))) == NULL)
3047 return (S_ERROR);
3048
3049 *csym = *osdp->sd_sym;
3050 csym->st_info = ELF_ST_INFO(STB_LOCAL,
3051 ELF_ST_TYPE(osdp->sd_sym->st_info));
3052
3053 osdp->sd_name = cname;
3054 osdp->sd_sym = csym;
3055 osdp->sd_flags = FLG_SY_CAP;
3056
3057 /*
3058 * Keep track of this new local symbol. As -z symbolcap
3059 * can only be used to create a relocatable object, a
3060 * dynamic symbol table can't exist. Ensure there is
3061 * space reserved in the string table.
3062 */
3063 ofl->ofl_caploclcnt++;
3064 if (st_insert(ofl->ofl_strtab, cname) == -1)
3065 return (S_ERROR);
3066
3067 DBG_CALL(Dbg_syms_cap_local(ofl, cpp1->c_ndx,
3068 cname, csym, osdp));
3069
3070 /*
3071 * Establish this capability pair as a family.
3072 */
3073 if (ld_cap_add_family(ofl, cpp1->c_nsdp, osdp,
3074 cpp1->c_group, &ifl->ifl_caps->ca_syms) == S_ERROR)
3075 return (S_ERROR);
3076 }
3077 }
3078
3079 return (1);
3080
3081 #undef SYM_LOC_BADADDR
3082 }
3083
3084 /*
3085 * Add an undefined symbol to the symbol table. The reference originates from
3086 * the location identified by the message id (mid). These references can
3087 * originate from command line options such as -e, -u, -initarray, etc.
3088 * (identified with MSG_INTL(MSG_STR_COMMAND)), or from internally generated
3089 * TLS relocation references (identified with MSG_INTL(MSG_STR_TLSREL)).
3090 */
3091 Sym_desc *
3092 ld_sym_add_u(const char *name, Ofl_desc *ofl, Msg mid)
3093 {
3094 Sym *sym;
3095 Ifl_desc *ifl = NULL, *_ifl;
3096 Sym_desc *sdp;
3097 Word hash;
3098 Aliste idx;
3099 avl_index_t where;
3100 const char *reference = MSG_INTL(mid);
3101
3102 /*
3103 * As an optimization, determine whether we've already generated this
3104 * reference. If the symbol doesn't already exist we'll create it.
3105 * Or if the symbol does exist from a different source, we'll resolve
3106 * the conflict.
3107 */
3108 /* LINTED */
3109 hash = (Word)elf_hash(name);
3110 if ((sdp = ld_sym_find(name, hash, &where, ofl)) != NULL) {
3111 if ((sdp->sd_sym->st_shndx == SHN_UNDEF) &&
3112 (sdp->sd_file->ifl_name == reference))
3113 return (sdp);
3114 }
3115
3116 /*
3117 * Determine whether a pseudo input file descriptor exists to represent
3118 * the command line, as any global symbol needs an input file descriptor
3119 * during any symbol resolution (refer to map_ifl() which provides a
3120 * similar method for adding symbols from mapfiles).
3121 */
3122 for (APLIST_TRAVERSE(ofl->ofl_objs, idx, _ifl))
3123 if (strcmp(_ifl->ifl_name, reference) == 0) {
3124 ifl = _ifl;
3125 break;
3126 }
3127
3128 /*
3129 * If no descriptor exists create one.
3130 */
3131 if (ifl == NULL) {
3132 if ((ifl = libld_calloc(sizeof (Ifl_desc), 1)) == NULL)
3133 return ((Sym_desc *)S_ERROR);
3134 ifl->ifl_name = reference;
3135 ifl->ifl_flags = FLG_IF_NEEDED | FLG_IF_FILEREF;
3136 if ((ifl->ifl_ehdr = libld_calloc(sizeof (Ehdr), 1)) == NULL)
3137 return ((Sym_desc *)S_ERROR);
3138 ifl->ifl_ehdr->e_type = ET_REL;
3139
3140 if (aplist_append(&ofl->ofl_objs, ifl, AL_CNT_OFL_OBJS) == NULL)
3141 return ((Sym_desc *)S_ERROR);
3142 }
3143
3144 /*
3145 * Allocate a symbol structure and add it to the global symbol table.
3146 */
3147 if ((sym = libld_calloc(sizeof (Sym), 1)) == NULL)
3148 return ((Sym_desc *)S_ERROR);
3149 sym->st_info = ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE);
3150 sym->st_shndx = SHN_UNDEF;
3151
3152 DBG_CALL(Dbg_syms_process(ofl->ofl_lml, ifl));
3153 if (sdp == NULL) {
3154 DBG_CALL(Dbg_syms_global(ofl->ofl_lml, 0, name));
3155 if ((sdp = ld_sym_enter(name, sym, hash, ifl, ofl, 0, SHN_UNDEF,
3156 0, &where)) == (Sym_desc *)S_ERROR)
3157 return ((Sym_desc *)S_ERROR);
3158 } else if (ld_sym_resolve(sdp, sym, ifl, ofl, 0,
3159 SHN_UNDEF, 0) == S_ERROR)
3160 return ((Sym_desc *)S_ERROR);
3161
3162 sdp->sd_flags &= ~FLG_SY_CLEAN;
3163 sdp->sd_flags |= FLG_SY_CMDREF;
3164
3165 return (sdp);
3166 }
3167
3168 /*
3169 * STT_SECTION symbols have their st_name field set to NULL, and consequently
3170 * have no name. Generate a name suitable for diagnostic use for such a symbol
3171 * and store it in the input section descriptor. The resulting name will be
3172 * of the form:
3173 *
3174 * "XXX (section)"
3175 *
3176 * where XXX is the name of the section.
3177 *
3178 * entry:
3179 * isc - Input section associated with the symbol.
3180 * fmt - NULL, or format string to use.
3181 *
3182 * exit:
3183 * Sets isp->is_sym_name to the allocated string. Returns the
3184 * string pointer, or NULL on allocation failure.
3185 */
3186 const char *
3187 ld_stt_section_sym_name(Is_desc *isp)
3188 {
3189 const char *fmt;
3190 char *str;
3191 size_t len;
3192
3193 if ((isp == NULL) || (isp->is_name == NULL))
3194 return (NULL);
3195
3196 if (isp->is_sym_name == NULL) {
3197 fmt = (isp->is_flags & FLG_IS_GNSTRMRG) ?
3198 MSG_INTL(MSG_STR_SECTION_MSTR) : MSG_INTL(MSG_STR_SECTION);
3199
3200 len = strlen(fmt) + strlen(isp->is_name) + 1;
3201
3202 if ((str = libld_malloc(len)) == NULL)
3203 return (NULL);
3204 (void) snprintf(str, len, fmt, isp->is_name);
3205 isp->is_sym_name = str;
3206 }
3207
3208 return (isp->is_sym_name);
3209 }