xref: /illumos-gate/usr/src/cmd/sgs/liblddbg/common/syms.c (revision 02938ba2)
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) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 #include	<stdio.h>
27 #include	"msg.h"
28 #include	"_debug.h"
29 #include	"libld.h"
30 
31 #if	!(defined(_ELF64))
32 
33 void
Dbg_syms_lookup_aout(Lm_list * lml,const char * name)34 Dbg_syms_lookup_aout(Lm_list *lml, const char *name)
35 {
36 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
37 		return;
38 
39 	dbg_print(lml, MSG_INTL(MSG_SYM_AOUT), Dbg_demangle_name(name));
40 }
41 
42 #endif
43 
44 void
Dbg_syms_lookup(Rt_map * lmp,const char * name,const char * type)45 Dbg_syms_lookup(Rt_map *lmp, const char *name, const char *type)
46 {
47 	Lm_list	*lml = LIST(lmp);
48 
49 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
50 		return;
51 
52 	dbg_print(lml, MSG_INTL(MSG_SYM_LOOKUP), Dbg_demangle_name(name),
53 	    NAME(lmp), type);
54 }
55 
56 static	const Msg captype[DBG_CAP_MACH + 1] = {
57 	MSG_CAP_SYM_DEFAULT,		/* MSG_INTL(MSG_CAP_SYM_DEFAULT) */
58 	MSG_CAP_SYM_USED,		/* MSG_INTL(MSG_CAP_SYM_USED) */
59 	MSG_CAP_SYM_CANDIDATE,		/* MSG_INTL(MSG_CAP_SYM_CANDIDATE) */
60 	MSG_CAP_SYM_REJECTED,		/* MSG_INTL(MSG_CAP_SYM_REJECTED) */
61 	MSG_CAP_SYM_HW_1,		/* MSG_INTL(MSG_CAP_SYM_HW_1) */
62 	MSG_CAP_SYM_SF_1,		/* MSG_INTL(MSG_CAP_SYM_SF_1) */
63 	MSG_CAP_SYM_HW_2,		/* MSG_INTL(MSG_CAP_SYM_HW_2) */
64 	MSG_CAP_SYM_PLAT,		/* MSG_INTL(MSG_CAP_SYM_PLAT) */
65 	MSG_CAP_SYM_MACH		/* MSG_INTL(MSG_CAP_SYM_MACH) */
66 };
67 
68 void
Dbg_syms_cap_lookup(Rt_map * lmp,uint_t type,const char * name,uint_t ndx,Half mach,Syscapset * scapset)69 Dbg_syms_cap_lookup(Rt_map *lmp, uint_t type, const char *name, uint_t ndx,
70     Half mach, Syscapset *scapset)
71 {
72 	Lm_list			*lml = LIST(lmp);
73 	const char		*str = NULL;
74 	Conv_cap_val_buf_t	cap_val_buf;
75 
76 	if (DBG_NOTCLASS(DBG_C_CAP | DBG_C_SYMBOLS))
77 		return;
78 
79 	switch (type) {
80 	case DBG_CAP_HW_1:
81 		str = conv_cap_val_hw1(scapset->sc_hw_1, mach, 0,
82 		    &cap_val_buf.cap_val_hw1_buf);
83 		break;
84 	case DBG_CAP_SF_1:
85 		str = conv_cap_val_sf1(scapset->sc_sf_1, mach, 0,
86 		    &cap_val_buf.cap_val_sf1_buf);
87 		break;
88 	case DBG_CAP_HW_2:
89 		str = conv_cap_val_hw2(scapset->sc_hw_2, mach, 0,
90 		    &cap_val_buf.cap_val_hw2_buf);
91 		break;
92 	case DBG_CAP_MACH:
93 		str = scapset->sc_mach;
94 		break;
95 	case DBG_CAP_PLAT:
96 		str = scapset->sc_plat;
97 		break;
98 	}
99 
100 	dbg_print(lml, MSG_INTL(captype[type]), Dbg_demangle_name(name),
101 	    ndx, str);
102 }
103 
104 void
Dbg_syms_ignore_gnuver(Rt_map * lmp,const char * name,Word symndx,Versym verndx)105 Dbg_syms_ignore_gnuver(Rt_map *lmp, const char *name, Word symndx,
106     Versym verndx)
107 {
108 	Lm_list	*lml = LIST(lmp);
109 
110 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
111 		return;
112 
113 	dbg_print(lml, MSG_INTL(MSG_SYM_IGNGNUVER), Dbg_demangle_name(name),
114 	    EC_WORD(symndx), EC_HALF(verndx), NAME(lmp));
115 }
116 
117 void
Dbg_syms_lazy_rescan(Lm_list * lml,const char * name)118 Dbg_syms_lazy_rescan(Lm_list *lml, const char *name)
119 {
120 	if (DBG_NOTCLASS(DBG_C_SYMBOLS | DBG_C_FILES))
121 		return;
122 
123 	Dbg_util_nl(lml, DBG_NL_STD);
124 	dbg_print(lml, MSG_INTL(MSG_SYM_LAZY_RESCAN), Dbg_demangle_name(name));
125 }
126 
127 void
Dbg_syms_ar_title(Lm_list * lml,const char * file,Boolean again)128 Dbg_syms_ar_title(Lm_list *lml, const char *file, Boolean again)
129 {
130 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
131 		return;
132 
133 	dbg_print(lml, MSG_INTL(MSG_SYM_AR_FILE), file,
134 	    again ? MSG_INTL(MSG_STR_AGAIN) : MSG_ORIG(MSG_STR_EMPTY));
135 }
136 
137 void
Dbg_syms_ar_skip(Lm_list * lml,const char * archive,Elf_Arsym * arsym)138 Dbg_syms_ar_skip(Lm_list *lml, const char *archive, Elf_Arsym *arsym)
139 {
140 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
141 		return;
142 
143 	dbg_print(lml, MSG_INTL(MSG_SYM_AR_SKIP), archive,
144 	    Dbg_demangle_name(arsym->as_name));
145 }
146 
147 void
Dbg_syms_ar_checking(Lm_list * lml,const char * fname,const char * objname,Elf_Arsym * arsym)148 Dbg_syms_ar_checking(Lm_list *lml, const char *fname, const char *objname,
149     Elf_Arsym *arsym)
150 {
151 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
152 		return;
153 
154 	dbg_print(lml, MSG_INTL(MSG_SYM_AR_CHECK), fname, objname,
155 	    Dbg_demangle_name(arsym->as_name));
156 }
157 
158 void
Dbg_syms_ar_resolve(Lm_list * lml,const char * fname,const char * objname,Elf_Arsym * arsym)159 Dbg_syms_ar_resolve(Lm_list *lml, const char *fname, const char *objname,
160     Elf_Arsym *arsym)
161 {
162 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
163 		return;
164 
165 	dbg_print(lml, MSG_INTL(MSG_SYM_AR_RESOLVE), fname, objname,
166 	    Dbg_demangle_name(arsym->as_name));
167 }
168 
169 void
Dbg_syms_ar_force(Lm_list * lml,const char * fname,const char * objname)170 Dbg_syms_ar_force(Lm_list *lml, const char *fname, const char *objname)
171 {
172 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
173 		return;
174 
175 	dbg_print(lml, MSG_INTL(MSG_SYM_AR_FORCE), fname, objname);
176 }
177 
178 void
Dbg_syms_spec_title(Lm_list * lml)179 Dbg_syms_spec_title(Lm_list *lml)
180 {
181 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
182 		return;
183 
184 	Dbg_util_nl(lml, DBG_NL_STD);
185 	dbg_print(lml, MSG_INTL(MSG_SYM_SPECIAL));
186 }
187 
188 void
Dbg_syms_discarded(Lm_list * lml,Sym_desc * sdp)189 Dbg_syms_discarded(Lm_list *lml, Sym_desc *sdp)
190 {
191 	dbg_isec_name_buf_t	buf;
192 	char			*alloc_mem;
193 	const char		*file;
194 
195 	if (DBG_NOTCLASS(DBG_C_SYMBOLS | DBG_C_UNUSED))
196 		return;
197 	if (DBG_NOTDETAIL())
198 		return;
199 
200 	if ((sdp->sd_file == NULL) || ((file = sdp->sd_file->ifl_name) == NULL))
201 		file = MSG_INTL(MSG_STR_UNKNOWN);
202 
203 	if (sdp->sd_isc) {
204 		dbg_print(lml, MSG_INTL(MSG_SYM_DISCARD_SEC),
205 		    Dbg_demangle_name(sdp->sd_name),
206 		    dbg_fmt_isec_name(sdp->sd_isc, buf, &alloc_mem), file);
207 		if (alloc_mem != NULL)
208 			free(alloc_mem);
209 	} else
210 		dbg_print(lml, MSG_INTL(MSG_SYM_DISCARD_FILE),
211 		    Dbg_demangle_name(sdp->sd_name), file);
212 }
213 
214 void
Dbg_syms_dup_discarded(Lm_list * lml,Word ndx,Sym_desc * sdp)215 Dbg_syms_dup_discarded(Lm_list *lml, Word ndx, Sym_desc *sdp)
216 {
217 	const char	*file;
218 
219 	if (DBG_NOTCLASS(DBG_C_SYMBOLS | DBG_C_UNUSED))
220 		return;
221 	if (DBG_NOTDETAIL())
222 		return;
223 
224 	if ((sdp->sd_file == NULL) || ((file = sdp->sd_file->ifl_name) == NULL))
225 		file = MSG_INTL(MSG_STR_UNKNOWN);
226 
227 	dbg_print(lml, MSG_INTL(MSG_SYM_DISCARD_DUP), EC_WORD(ndx),
228 	    Dbg_demangle_name(sdp->sd_name), file);
229 }
230 
231 void
Dbg_syms_entered(Ofl_desc * ofl,Sym * sym,Sym_desc * sdp)232 Dbg_syms_entered(Ofl_desc *ofl, Sym *sym, Sym_desc *sdp)
233 {
234 	Conv_inv_buf_t	inv_buf;
235 	Lm_list		*lml = ofl->ofl_lml;
236 
237 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
238 		return;
239 	if (DBG_NOTDETAIL())
240 		return;
241 
242 	Elf_syms_table_entry(lml, ELF_DBG_LD, MSG_INTL(MSG_STR_ENTERED),
243 	    ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine, sym,
244 	    sdp->sd_aux ? sdp->sd_aux->sa_overndx : 0, 0, NULL,
245 	    conv_def_tag(sdp->sd_ref, &inv_buf));
246 }
247 
248 void
Dbg_syms_process(Lm_list * lml,Ifl_desc * ifl)249 Dbg_syms_process(Lm_list *lml, Ifl_desc *ifl)
250 {
251 	Conv_inv_buf_t	inv_buf;
252 
253 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
254 		return;
255 
256 	Dbg_util_nl(lml, DBG_NL_STD);
257 	dbg_print(lml, MSG_INTL(MSG_SYM_PROCESS), ifl->ifl_name,
258 	    conv_ehdr_type(ifl->ifl_ehdr->e_ident[EI_OSABI],
259 	    ifl->ifl_ehdr->e_type, 0, &inv_buf));
260 }
261 
262 void
Dbg_syms_entry(Lm_list * lml,Word ndx,Sym_desc * sdp)263 Dbg_syms_entry(Lm_list *lml, Word ndx, Sym_desc *sdp)
264 {
265 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
266 		return;
267 
268 	dbg_print(lml, MSG_INTL(MSG_SYM_BASIC), EC_WORD(ndx),
269 	    Dbg_demangle_name(sdp->sd_name));
270 }
271 
272 void
Dbg_syms_global(Lm_list * lml,Word ndx,const char * name)273 Dbg_syms_global(Lm_list *lml, Word ndx, const char *name)
274 {
275 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
276 		return;
277 
278 	dbg_print(lml, MSG_INTL(MSG_SYM_ADDING), EC_WORD(ndx),
279 	    Dbg_demangle_name(name));
280 }
281 
282 void
Dbg_syms_cap_convert(Ofl_desc * ofl,Word ndx,const char * name,Sym * sym)283 Dbg_syms_cap_convert(Ofl_desc *ofl, Word ndx, const char *name, Sym *sym)
284 {
285 	if (DBG_NOTCLASS(DBG_C_CAP | DBG_C_SYMBOLS))
286 		return;
287 
288 	dbg_print(ofl->ofl_lml, MSG_INTL(MSG_SYM_CAP_ORIG), EC_WORD(ndx),
289 	    Dbg_demangle_name(name));
290 
291 	if (DBG_NOTDETAIL())
292 		return;
293 
294 	Elf_syms_table_entry(ofl->ofl_lml, ELF_DBG_LD,
295 	    MSG_INTL(MSG_STR_ORIGINAL), ofl->ofl_dehdr->e_ident[EI_OSABI],
296 	    ofl->ofl_dehdr->e_machine, sym, 0, 0, NULL,
297 	    MSG_ORIG(MSG_STR_EMPTY));
298 }
299 
300 void
Dbg_syms_cap_local(Ofl_desc * ofl,Word ndx,const char * name,Sym * sym,Sym_desc * sdp)301 Dbg_syms_cap_local(Ofl_desc *ofl, Word ndx, const char *name, Sym *sym,
302     Sym_desc *sdp)
303 {
304 	Conv_inv_buf_t	inv_buf;
305 
306 	if (DBG_NOTCLASS(DBG_C_CAP | DBG_C_SYMBOLS))
307 		return;
308 
309 	dbg_print(ofl->ofl_lml, MSG_INTL(MSG_SYM_CAP_LOCAL), EC_WORD(ndx),
310 	    Dbg_demangle_name(name));
311 
312 	if (DBG_NOTDETAIL())
313 		return;
314 
315 	Elf_syms_table_entry(ofl->ofl_lml, ELF_DBG_LD,
316 	    MSG_INTL(MSG_STR_ENTERED), ofl->ofl_dehdr->e_ident[EI_OSABI],
317 	    ofl->ofl_dehdr->e_machine, sym,
318 	    sdp->sd_aux ? sdp->sd_aux->sa_overndx : 0, 0, NULL,
319 	    conv_def_tag(sdp->sd_ref, &inv_buf));
320 }
321 
322 void
Dbg_syms_wrap(Lm_list * lml,Word ndx,const char * orig_name,const char * name)323 Dbg_syms_wrap(Lm_list *lml, Word ndx, const char *orig_name, const char *name)
324 {
325 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
326 		return;
327 
328 	dbg_print(lml, MSG_INTL(MSG_SYM_WRAP), EC_WORD(ndx),
329 	    Dbg_demangle_name(orig_name), Dbg_demangle_name(name));
330 }
331 
332 void
Dbg_syms_sec_title(Lm_list * lml)333 Dbg_syms_sec_title(Lm_list *lml)
334 {
335 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
336 		return;
337 	if (DBG_NOTDETAIL())
338 		return;
339 
340 	Dbg_util_nl(lml, DBG_NL_STD);
341 	dbg_print(lml, MSG_INTL(MSG_SYM_INDEX));
342 }
343 
344 void
Dbg_syms_sec_entry(Lm_list * lml,Word ndx,Sg_desc * sgp,Os_desc * osp)345 Dbg_syms_sec_entry(Lm_list *lml, Word ndx, Sg_desc *sgp, Os_desc *osp)
346 {
347 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
348 		return;
349 	if (DBG_NOTDETAIL())
350 		return;
351 
352 	dbg_print(lml, MSG_INTL(MSG_SYM_SECTION), EC_WORD(ndx), osp->os_name,
353 	    (*sgp->sg_name ? sgp->sg_name : MSG_INTL(MSG_STR_NULL)));
354 }
355 
356 void
Dbg_syms_up_title(Lm_list * lml)357 Dbg_syms_up_title(Lm_list *lml)
358 {
359 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
360 		return;
361 	if (DBG_NOTDETAIL())
362 		return;
363 
364 	Dbg_util_nl(lml, DBG_NL_STD);
365 	dbg_print(lml, MSG_INTL(MSG_SYM_FINAL));
366 	Elf_syms_table_title(lml, ELF_DBG_LD);
367 }
368 
369 void
Dbg_syms_ignore(Ofl_desc * ofl,Sym_desc * sdp)370 Dbg_syms_ignore(Ofl_desc *ofl, Sym_desc *sdp)
371 {
372 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
373 		return;
374 	if (DBG_NOTDETAIL())
375 		return;
376 
377 	Elf_syms_table_entry(ofl->ofl_lml, ELF_DBG_LD, MSG_INTL(MSG_STR_IGNORE),
378 	    ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine,
379 	    sdp->sd_sym, 0, 0, NULL, MSG_INTL(MSG_STR_UNUSED));
380 }
381 
382 void
Dbg_syms_old(Ofl_desc * ofl,Sym_desc * sdp)383 Dbg_syms_old(Ofl_desc *ofl, Sym_desc *sdp)
384 {
385 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
386 		return;
387 	if (DBG_NOTDETAIL())
388 		return;
389 
390 	Elf_syms_table_entry(ofl->ofl_lml, ELF_DBG_LD, MSG_INTL(MSG_STR_OLD),
391 	    ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine,
392 	    sdp->sd_sym, sdp->sd_aux ? sdp->sd_aux->sa_overndx : 0,
393 	    0, NULL, sdp->sd_name);
394 }
395 
396 void
Dbg_syms_new(Ofl_desc * ofl,Sym * sym,Sym_desc * sdp)397 Dbg_syms_new(Ofl_desc *ofl, Sym *sym, Sym_desc *sdp)
398 {
399 	Conv_inv_buf_t	inv_buf;
400 
401 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
402 		return;
403 	if (DBG_NOTDETAIL())
404 		return;
405 
406 	Elf_syms_table_entry(ofl->ofl_lml, ELF_DBG_LD, MSG_INTL(MSG_STR_NEW),
407 	    ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine, sym,
408 	    sdp->sd_aux ? sdp->sd_aux->sa_overndx : 0, 0, NULL,
409 	    conv_def_tag(sdp->sd_ref, &inv_buf));
410 }
411 
412 void
Dbg_syms_updated(Ofl_desc * ofl,Sym_desc * sdp,const char * name)413 Dbg_syms_updated(Ofl_desc *ofl, Sym_desc *sdp, const char *name)
414 {
415 	Conv_inv_buf_t	inv_buf;
416 	Lm_list		*lml = ofl->ofl_lml;
417 
418 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
419 		return;
420 
421 	dbg_print(lml, MSG_INTL(MSG_SYM_UPDATE), name);
422 
423 	if (DBG_NOTDETAIL())
424 		return;
425 
426 	Elf_syms_table_entry(ofl->ofl_lml, ELF_DBG_LD, MSG_ORIG(MSG_STR_EMPTY),
427 	    ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine,
428 	    sdp->sd_sym, sdp->sd_aux ? sdp->sd_aux->sa_overndx : 0, 0, NULL,
429 	    conv_def_tag(sdp->sd_ref, &inv_buf));
430 }
431 
432 void
Dbg_syms_created(Lm_list * lml,const char * name)433 Dbg_syms_created(Lm_list *lml, const char *name)
434 {
435 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
436 		return;
437 
438 	dbg_print(lml, MSG_INTL(MSG_SYM_CREATE), Dbg_demangle_name(name));
439 }
440 
441 void
Dbg_syms_resolving(Ofl_desc * ofl,Word ndx,const char * name,int row,int col,Sym * osym,Sym * nsym,Sym_desc * sdp,Ifl_desc * ifl)442 Dbg_syms_resolving(Ofl_desc *ofl, Word ndx, const char *name, int row,
443     int col, Sym *osym, Sym *nsym, Sym_desc *sdp, Ifl_desc *ifl)
444 {
445 	Lm_list	*lml = ofl->ofl_lml;
446 	uchar_t	osabi = ofl->ofl_dehdr->e_ident[EI_OSABI];
447 	Half	mach = ofl->ofl_dehdr->e_machine;
448 
449 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
450 		return;
451 
452 	dbg_print(lml, MSG_INTL(MSG_SYM_RESOLVING), EC_WORD(ndx),
453 	    Dbg_demangle_name(name), row, col);
454 
455 	if (DBG_NOTDETAIL())
456 		return;
457 
458 	Elf_syms_table_entry(ofl->ofl_lml, ELF_DBG_LD, MSG_INTL(MSG_STR_OLD),
459 	    osabi, mach, osym, sdp->sd_aux ? sdp->sd_aux->sa_overndx : 0,
460 	    0, NULL, sdp->sd_file->ifl_name);
461 
462 	Elf_syms_table_entry(ofl->ofl_lml, ELF_DBG_LD, MSG_INTL(MSG_STR_NEW),
463 	    osabi, mach, nsym, 0, 0, NULL, ifl->ifl_name);
464 }
465 
466 void
Dbg_syms_resolved(Ofl_desc * ofl,Sym_desc * sdp)467 Dbg_syms_resolved(Ofl_desc *ofl, Sym_desc *sdp)
468 {
469 	Conv_inv_buf_t	inv_buf;
470 
471 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
472 		return;
473 	if (DBG_NOTDETAIL())
474 		return;
475 
476 	Elf_syms_table_entry(ofl->ofl_lml, ELF_DBG_LD,
477 	    MSG_INTL(MSG_STR_RESOLVED), ofl->ofl_dehdr->e_ident[EI_OSABI],
478 	    ofl->ofl_dehdr->e_machine, sdp->sd_sym,
479 	    sdp->sd_aux ? sdp->sd_aux->sa_overndx : 0, 0, NULL,
480 	    conv_def_tag(sdp->sd_ref, &inv_buf));
481 }
482 
483 void
Dbg_syms_copy_reloc(Ofl_desc * ofl,Sym_desc * sdp,Word align)484 Dbg_syms_copy_reloc(Ofl_desc *ofl, Sym_desc *sdp, Word align)
485 {
486 	static Boolean	symbol_title = TRUE;
487 	Conv_inv_buf_t	inv_buf;
488 	Lm_list	*lml = ofl->ofl_lml;
489 
490 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
491 		return;
492 
493 	if (symbol_title) {
494 		Dbg_util_nl(lml, DBG_NL_STD);
495 		dbg_print(lml, MSG_INTL(MSG_SYM_BSS));
496 
497 		symbol_title = FALSE;
498 	}
499 
500 	/*
501 	 * Copy relocation symbols come in pairs, the original reference
502 	 * (within a dependency), and the new destination (within the .bss of
503 	 * the executable).  The latter is accompanied with a computed
504 	 * alignment.
505 	 */
506 	if (align) {
507 		dbg_print(lml, MSG_INTL(MSG_SYM_COPY_DST),
508 		    Dbg_demangle_name(sdp->sd_name), EC_WORD(align));
509 	} else {
510 		dbg_print(lml, MSG_INTL(MSG_SYM_COPY_REF),
511 		    Dbg_demangle_name(sdp->sd_name));
512 	}
513 
514 	if (DBG_NOTDETAIL())
515 		return;
516 
517 	Elf_syms_table_entry(lml, ELF_DBG_LD, MSG_ORIG(MSG_SYM_COPY),
518 	    ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine,
519 	    sdp->sd_sym, sdp->sd_aux ? sdp->sd_aux->sa_overndx : 0, 0, NULL,
520 	    conv_def_tag(sdp->sd_ref, &inv_buf));
521 }
522 
523 void
Dbg_syms_reduce(Ofl_desc * ofl,int which,Sym_desc * sdp,int idx,const char * sname)524 Dbg_syms_reduce(Ofl_desc *ofl, int which, Sym_desc *sdp, int idx,
525     const char *sname)
526 {
527 	static Boolean	sym_reduce_title = TRUE;
528 	static Boolean	sym_retain_title = TRUE;
529 	Boolean		isfromglobal = (which == DBG_SYM_REDUCE_GLOBAL);
530 	Boolean		isfromretain = (which == DBG_SYM_REDUCE_RETAIN);
531 	Lm_list		*lml = ofl->ofl_lml;
532 
533 	if (DBG_NOTCLASS(DBG_C_SYMBOLS | DBG_C_VERSIONS))
534 		return;
535 
536 	if (sym_reduce_title && isfromglobal) {
537 		sym_reduce_title = FALSE;
538 		Dbg_util_nl(lml, DBG_NL_STD);
539 		dbg_print(lml, MSG_INTL(MSG_SYM_REDUCED));
540 	} else if (sym_retain_title && isfromretain) {
541 		sym_retain_title = FALSE;
542 		Dbg_util_nl(lml, DBG_NL_STD);
543 		dbg_print(lml, MSG_INTL(MSG_SYM_RETAINING));
544 	}
545 
546 	if ((sdp->sd_flags & FLG_SY_ELIM) && isfromglobal)
547 		dbg_print(lml, MSG_INTL(MSG_SYM_ELIMINATING),
548 		    Dbg_demangle_name(sdp->sd_name));
549 	else if (isfromglobal)
550 		dbg_print(lml, MSG_INTL(MSG_SYM_REDUCING),
551 		    Dbg_demangle_name(sdp->sd_name));
552 	else
553 		dbg_print(lml, MSG_INTL(MSG_SYM_NOTELIMINATE),
554 		    Dbg_demangle_name(sdp->sd_name), sname, idx);
555 
556 	if (DBG_NOTDETAIL())
557 		return;
558 
559 	Elf_syms_table_entry(ofl->ofl_lml, ELF_DBG_LD, MSG_ORIG(MSG_SYM_LOCAL),
560 	    ofl->ofl_dehdr->e_ident[EI_OSABI], ofl->ofl_dehdr->e_machine,
561 	    sdp->sd_sym, sdp->sd_aux ? sdp->sd_aux->sa_overndx : 0, 0, NULL,
562 	    sdp->sd_file->ifl_name);
563 }
564 
565 void
Dbg_syms_dup_sort_addr(Lm_list * lml,const char * secname,const char * symname1,const char * symname2,Addr addr)566 Dbg_syms_dup_sort_addr(Lm_list *lml, const char *secname, const char *symname1,
567     const char *symname2, Addr addr)
568 {
569 	if (DBG_NOTCLASS(DBG_C_SYMBOLS) || DBG_NOTDETAIL())
570 		return;
571 
572 	dbg_print(lml, MSG_INTL(MSG_SYM_DUPSORTADDR), secname,
573 	    symname1, symname2, EC_ADDR(addr));
574 }
575 
576 void
Dbg_syminfo_title(Lm_list * lml)577 Dbg_syminfo_title(Lm_list *lml)
578 {
579 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
580 		return;
581 	if (DBG_NOTDETAIL())
582 		return;
583 
584 	Dbg_util_nl(lml, DBG_NL_STD);
585 	dbg_print(lml, MSG_INTL(MSG_SYMINFO_INFO));
586 	Elf_syminfo_title(lml);
587 }
588 
589 void
Dbg_syminfo_entry(Lm_list * lml,Word ndx,Syminfo * sip,Sym * sym,const char * strtab,Dyn * dyn)590 Dbg_syminfo_entry(Lm_list *lml, Word ndx, Syminfo *sip, Sym *sym,
591     const char *strtab, Dyn *dyn)
592 {
593 	const char	*needed;
594 
595 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
596 		return;
597 	if (DBG_NOTDETAIL())
598 		return;
599 
600 	if (sip->si_boundto < SYMINFO_BT_LOWRESERVE)
601 		needed = strtab + dyn[sip->si_boundto].d_un.d_val;
602 	else
603 		needed = 0;
604 
605 	Elf_syminfo_entry(lml, ndx, sip,
606 	    Dbg_demangle_name(strtab + sym->st_name), needed);
607 }
608 
609 /*
610  * Symbol table output can differ slightly depending on the caller.  However,
611  * the final diagnostic is maintained here so hat the various message strings
612  * remain consistent
613  *
614  * elfdump:   index    value       size     type bind oth ver shndx       name
615  * ld:                 value       size     type bind oth ver shndx
616  */
617 void
Elf_syms_table_title(Lm_list * lml,int caller)618 Elf_syms_table_title(Lm_list *lml, int caller)
619 {
620 	if (caller == ELF_DBG_ELFDUMP) {
621 		if (DBG_NOTLONG())
622 			dbg_print(lml, MSG_INTL(MSG_SYM_EFS_TITLE));
623 		else
624 			dbg_print(lml, MSG_INTL(MSG_SYM_EFL_TITLE));
625 		return;
626 	}
627 
628 	if (caller == ELF_DBG_LD) {
629 		if (DBG_NOTLONG())
630 			dbg_print(lml, MSG_INTL(MSG_SYM_LDS_TITLE));
631 		else
632 			dbg_print(lml, MSG_INTL(MSG_SYM_LDL_TITLE));
633 		return;
634 	}
635 }
636 
637 void
Elf_syms_table_entry(Lm_list * lml,int caller,const char * prestr,uchar_t osabi,Half mach,Sym * sym,Versym verndx,int gnuver,const char * sec,const char * poststr)638 Elf_syms_table_entry(Lm_list *lml, int caller, const char *prestr,
639     uchar_t osabi, Half mach, Sym *sym, Versym verndx, int gnuver,
640     const char *sec, const char *poststr)
641 {
642 	Conv_inv_buf_t	inv_buf1, inv_buf2, inv_buf3;
643 	Conv_inv_buf_t	inv_buf4, inv_buf5, inv_buf6;
644 	uchar_t		type = ELF_ST_TYPE(sym->st_info);
645 	uchar_t		bind = ELF_ST_BIND(sym->st_info);
646 	const char	*msg;
647 
648 	if ((caller == ELF_DBG_ELFDUMP) ||
649 	    (caller == ELF_DBG_LD)) {
650 		if (DBG_NOTLONG())
651 			msg = MSG_INTL(MSG_SYM_EFS_ENTRY);
652 		else
653 			msg = MSG_INTL(MSG_SYM_EFL_ENTRY);
654 
655 		if (sec == NULL)
656 			sec = conv_sym_shndx(osabi, mach, sym->st_shndx,
657 			    CONV_FMT_DECIMAL, &inv_buf6);
658 
659 		dbg_print(lml, msg, prestr,
660 		    conv_sym_value(mach, type, sym->st_value, &inv_buf1),
661 		    sym->st_size, conv_sym_info_type(mach, type, 0, &inv_buf2),
662 		    conv_sym_info_bind(bind, 0, &inv_buf3),
663 		    conv_sym_other(sym->st_other, &inv_buf4),
664 		    conv_ver_index(verndx, gnuver, &inv_buf5),
665 		    sec, Elf_demangle_name(poststr));
666 	}
667 }
668 
669 void
Dbg_syms_cap_title(Ofl_desc * ofl)670 Dbg_syms_cap_title(Ofl_desc *ofl)
671 {
672 	Lm_list	*lml = ofl->ofl_lml;
673 
674 	if (DBG_NOTCLASS(DBG_C_SYMBOLS))
675 		return;
676 	if (DBG_NOTDETAIL())
677 		return;
678 
679 	Dbg_util_nl(lml, DBG_NL_STD);
680 	dbg_print(lml, MSG_INTL(MSG_SYM_CAPABILITIES));
681 	Elf_syms_table_title(lml, ELF_DBG_LD);
682 }
683