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
33void
34Dbg_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
44void
45Dbg_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
56static	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
68void
69Dbg_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
104void
105Dbg_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
117void
118Dbg_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
127void
128Dbg_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
137void
138Dbg_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
147void
148Dbg_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
158void
159Dbg_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
169void
170Dbg_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
178void
179Dbg_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
188void
189Dbg_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
214void
215Dbg_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
231void
232Dbg_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
248void
249Dbg_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
262void
263Dbg_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
272void
273Dbg_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
282void
283Dbg_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
300void
301Dbg_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
322void
323Dbg_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
332void
333Dbg_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
344void
345Dbg_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
356void
357Dbg_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
369void
370Dbg_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
382void
383Dbg_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
396void
397Dbg_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
412void
413Dbg_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
432void
433Dbg_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
441void
442Dbg_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
466void
467Dbg_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
483void
484Dbg_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
523void
524Dbg_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
565void
566Dbg_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
576void
577Dbg_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
589void
590Dbg_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 */
617void
618Elf_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
637void
638Elf_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
669void
670Dbg_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