xref: /titanic_50/usr/src/cmd/sgs/liblddbg/common/util.c (revision 10d63b7db37a83b39c7f511cf9426c9d03ea0760)
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 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include	"msg.h"
28 #include	"_debug.h"
29 #include	"libld.h"
30 
31 /*
32  * If any run-time linker debugging is being carried out always indicate the
33  * fact and specify the point at which we transfer control to the main program.
34  */
35 void
36 Dbg_util_call_main(Rt_map *lmp)
37 {
38 	Lm_list	*lml = LIST(lmp);
39 
40 	Dbg_util_nl(lml, DBG_NL_FRC);
41 	dbg_print(lml, MSG_INTL(MSG_UTL_TRANS), NAME(lmp));
42 	Dbg_util_nl(lml, DBG_NL_FRC);
43 }
44 
45 void
46 Dbg_util_call_init(Rt_map *lmp, int flag)
47 {
48 	Lm_list		*lml = LIST(lmp);
49 	const char	*str;
50 
51 	if (DBG_NOTCLASS(DBG_C_INIT))
52 		return;
53 
54 	if (flag == DBG_INIT_SORT)
55 		str = MSG_INTL(MSG_UTL_SORT);
56 	else if (flag == DBG_INIT_PEND)
57 		str = MSG_INTL(MSG_UTL_PEND);
58 	else if (flag == DBG_INIT_DYN)
59 		str = MSG_INTL(MSG_UTL_DYN);
60 	else
61 		str = MSG_INTL(MSG_UTL_DONE);
62 
63 	Dbg_util_nl(lml, DBG_NL_STD);
64 	dbg_print(lml, MSG_INTL(MSG_UTL_INIT), str, NAME(lmp));
65 	Dbg_util_nl(lml, DBG_NL_STD);
66 }
67 
68 void
69 Dbg_util_intoolate(Rt_map *lmp)
70 {
71 	Lm_list	*lml = LIST(lmp);
72 
73 	Dbg_util_nl(lml, DBG_NL_STD);
74 	dbg_print(lml, MSG_INTL(MSG_UTL_INTOOLATE), NAME(lmp));
75 	Dbg_util_nl(lml, DBG_NL_STD);
76 }
77 
78 void
79 Dbg_util_dbnotify(Lm_list *lml, rd_event_e event, r_state_e state)
80 {
81 	const char	*estr;
82 	const char	*sstr;
83 
84 	if (DBG_NOTCLASS(DBG_C_FILES))
85 		return;
86 	if (DBG_NOTDETAIL())
87 		return;
88 
89 	switch (event) {
90 	case RD_PREINIT:
91 		estr = MSG_ORIG(MSG_UTL_EVNT_PREINIT);
92 		sstr = MSG_INTL(MSG_STR_NULL);
93 		break;
94 	case RD_POSTINIT:
95 		estr = MSG_ORIG(MSG_UTL_EVNT_POSTINIT);
96 		sstr = MSG_INTL(MSG_STR_NULL);
97 		break;
98 	case RD_DLACTIVITY:
99 		estr = MSG_ORIG(MSG_UTL_EVNT_DLACT);
100 		switch (state) {
101 		case RT_CONSISTENT:
102 			sstr = MSG_ORIG(MSG_UTL_STA_CONSIST);
103 			break;
104 		case RT_ADD:
105 			sstr = MSG_ORIG(MSG_UTL_STA_ADD);
106 			break;
107 		case RT_DELETE:
108 			sstr = MSG_ORIG(MSG_UTL_STA_DELETE);
109 			break;
110 		default:
111 			sstr = MSG_INTL(MSG_STR_NULL);
112 			break;
113 		}
114 		break;
115 	default:
116 		sstr = MSG_INTL(MSG_STR_NULL);
117 		estr = MSG_INTL(MSG_STR_UNKNOWN);
118 		break;
119 	}
120 
121 	Dbg_util_nl(lml, DBG_NL_STD);
122 	dbg_print(lml, MSG_INTL(MSG_UTL_DBNOTIFY), estr, sstr);
123 	Dbg_util_nl(lml, DBG_NL_STD);
124 }
125 
126 void
127 Dbg_util_call_array(Rt_map *lmp, void *addr, int ndx, Word shtype)
128 {
129 	Lm_list		*lml = LIST(lmp);
130 	const char	*str;
131 
132 	if (DBG_NOTCLASS(DBG_C_INIT))
133 		return;
134 
135 	if (shtype == SHT_INIT_ARRAY)
136 		str = MSG_ORIG(MSG_SCN_INITARRAY);
137 	else if (shtype == SHT_FINI_ARRAY)
138 		str = MSG_ORIG(MSG_SCN_FINIARRAY);
139 	else
140 		str = MSG_ORIG(MSG_SCN_PREINITARRAY);
141 
142 	dbg_print(lml, MSG_INTL(MSG_UTL_ARRAY), str, ndx, EC_NATPTR(addr),
143 	    NAME(lmp));
144 }
145 
146 void
147 Dbg_util_call_fini(Rt_map *lmp)
148 {
149 	Lm_list	*lml = LIST(lmp);
150 
151 	if (DBG_NOTCLASS(DBG_C_INIT))
152 		return;
153 
154 	Dbg_util_nl(lml, DBG_NL_STD);
155 	dbg_print(lml, MSG_INTL(MSG_UTL_FINI), NAME(lmp));
156 	Dbg_util_nl(lml, DBG_NL_STD);
157 }
158 
159 void
160 Dbg_util_str(Lm_list *lml, const char *str)
161 {
162 	Dbg_util_nl(lml, DBG_NL_STD);
163 	Dbg_util_nl(lml, DBG_NL_FRC);
164 	dbg_print(lml, MSG_ORIG(MSG_FMT_STR), str);
165 	Dbg_util_nl(lml, DBG_NL_FRC);
166 	Dbg_util_nl(lml, DBG_NL_STD);
167 }
168 
169 void
170 Dbg_util_scc_title(Lm_list *lml, int sec)
171 {
172 	const char	*_sec;
173 
174 	if (DBG_NOTCLASS(DBG_C_INIT))
175 		return;
176 	if (DBG_NOTDETAIL())
177 		return;
178 
179 	if (sec)
180 		_sec = MSG_INTL(MSG_UTL_SCC_SUBI);
181 	else
182 		_sec = MSG_INTL(MSG_UTL_SCC_SUBF);
183 
184 	Dbg_util_nl(lml, DBG_NL_STD);
185 	dbg_print(lml, MSG_INTL(MSG_UTL_SCC_TITLE), _sec);
186 }
187 
188 void
189 Dbg_util_scc_entry(Rt_map *lmp, uint_t idx)
190 {
191 	if (DBG_NOTCLASS(DBG_C_INIT))
192 		return;
193 	if (DBG_NOTDETAIL())
194 		return;
195 
196 	dbg_print(LIST(lmp), MSG_ORIG(MSG_UTL_SCC_ENTRY), idx, NAME(lmp));
197 }
198 
199 static	int ectoggle = 0;
200 
201 void
202 Dbg_util_edge_in(Lm_list *lml, Rt_map *clmp, uint_t flags, Rt_map *dlmp,
203     int ndx, int flag)
204 {
205 	Conv_bnd_type_buf_t	bnd_type_buf;
206 	const char		*str;
207 
208 	if (DBG_NOTCLASS(DBG_C_INIT))
209 		return;
210 	if (DBG_NOTDETAIL())
211 		return;
212 
213 	if (flag & RT_SORT_REV)
214 		str = MSG_ORIG(MSG_SCN_INIT);
215 	else
216 		str = MSG_ORIG(MSG_SCN_FINI);
217 
218 	if ((clmp == 0) || (ectoggle == 0))
219 		Dbg_util_nl(lml, DBG_NL_STD);
220 	if (clmp == 0) {
221 		if (flag & RT_SORT_INTPOSE)
222 			dbg_print(lml, MSG_INTL(MSG_UTL_EDGE_TITLE_I), str);
223 		else
224 			dbg_print(lml, MSG_INTL(MSG_UTL_EDGE_TITLE_S), str);
225 
226 		dbg_print(lml, MSG_INTL(MSG_UTL_EDGE_START), ndx, NAME(dlmp));
227 	} else
228 		dbg_print(lml, MSG_INTL(MSG_UTL_EDGE_IN), ndx, NAME(dlmp),
229 		    NAME(clmp), conv_bnd_type(flags, &bnd_type_buf));
230 
231 	ectoggle = 1;
232 }
233 
234 void
235 Dbg_util_edge_out(Rt_map *clmp, Rt_map *dlmp)
236 {
237 	if (DBG_NOTCLASS(DBG_C_INIT))
238 		return;
239 	if (DBG_NOTDETAIL())
240 		return;
241 
242 	dbg_print(LIST(clmp), MSG_INTL(MSG_UTL_EDGE_OUT), SORTVAL(clmp),
243 	    NAME(clmp), NAME(dlmp));
244 }
245 
246 void
247 Dbg_util_collect(Rt_map *lmp, int ndx, int flag)
248 {
249 	Lm_list		*lml = LIST(lmp);
250 	const char	*str;
251 
252 	if (DBG_NOTCLASS(DBG_C_INIT))
253 		return;
254 	if (DBG_NOTDETAIL())
255 		return;
256 
257 	if (flag & RT_SORT_REV)
258 		str = MSG_ORIG(MSG_SCN_INIT);
259 	else
260 		str = MSG_ORIG(MSG_SCN_FINI);
261 
262 	if (ectoggle == 1) {
263 		Dbg_util_nl(lml, DBG_NL_STD);
264 		ectoggle = 0;
265 	}
266 	dbg_print(lml, MSG_INTL(MSG_UTL_COLLECT), ndx, NAME(lmp), str);
267 }
268 
269 static const Msg	tags[] = {
270 	MSG_CI_NULL,		/* MSG_ORIG(MSG_CI_NULL) */
271 	MSG_CI_VERSION,		/* MSG_ORIG(MSG_CI_VERSION) */
272 	MSG_CI_ATEXIT,		/* MSG_ORIG(MSG_CI_ATEXIT) */
273 	MSG_CI_LCMESSAGES,	/* MSG_ORIG(MSG_CI_LCMESSAGES) */
274 	MSG_CI_BIND_GUARD,	/* MSG_ORIG(MSG_CI_BIND_GUARD) */
275 	MSG_CI_BIND_CLEAR,	/* MSG_ORIG(MSG_CI_BIND_CLEAR) */
276 	MSG_CI_THR_SELF,	/* MSG_ORIG(MSG_CI_THR_SELF) */
277 	MSG_CI_TLS_MODADD,	/* MSG_ORIG(MSG_CI_TLS_MODADD) */
278 	MSG_CI_TLS_MODREM,	/* MSG_ORIG(MSG_CI_TLS_MODREM) */
279 	MSG_CI_TLS_STATMOD,	/* MSG_ORIG(MSG_CI_TLS_STATMOD) */
280 	MSG_CI_THRINIT,		/* MSG_ORIG(MSG_CI_THRINIT) */
281 	MSG_CI_CRITICAL		/* MSG_ORIG(MSG_CI_CRITICAL) */
282 };
283 
284 void
285 Dbg_util_lcinterface(Rt_map *lmp, int tag, char *val)
286 {
287 	const char	*str;
288 	Conv_inv_buf_t	inv_buf;
289 
290 	if (DBG_NOTDETAIL())
291 		return;
292 
293 	if (tag < CI_MAX)
294 		str = MSG_ORIG(tags[tag]);
295 	else
296 		str = conv_invalid_val(&inv_buf, tag, 0);
297 
298 	dbg_print(LIST(lmp), MSG_INTL(MSG_UTL_LCINTERFACE), NAME(lmp), str,
299 	    EC_NATPTR(val));
300 }
301 
302 void
303 Dbg_unused_lcinterface(Rt_map *nlmp, Rt_map *olmp, int tag)
304 {
305 	const char	*str;
306 	Conv_inv_buf_t	inv_buf;
307 
308 	if (DBG_NOTCLASS(DBG_C_UNUSED))
309 		return;
310 
311 	if (tag < CI_MAX)
312 		str = MSG_ORIG(tags[tag]);
313 	else
314 		str = conv_invalid_val(&inv_buf, tag, 0);
315 
316 	dbg_print(LIST(nlmp), MSG_INTL(MSG_USD_LCINTERFACE), NAME(nlmp), str,
317 	    NAME(olmp));
318 }
319 
320 /*
321  * Generic new line generator.  To prevent multiple newlines from being
322  * generated, a flag is maintained in the global debug descriptor.  This flag
323  * is cleared by the callers dbg_print() function to indicate that a newline
324  * (actually, any line) has been printed.  Multiple newlines can be generated
325  * using the DBG_NL_FRC flag.
326  */
327 void
328 Dbg_util_nl(Lm_list *lml, int flag)
329 {
330 	if ((flag == DBG_NL_STD) && (dbg_desc->d_extra & DBG_E_STDNL))
331 		return;
332 
333 	dbg_print(lml, MSG_ORIG(MSG_STR_EMPTY));
334 
335 	if (flag == DBG_NL_STD)
336 		dbg_desc->d_extra |= DBG_E_STDNL;
337 }
338 
339 /*
340  * Define name demanglers.
341  */
342 const char *
343 Dbg_demangle_name(const char *name)
344 {
345 	if (DBG_NOTCLASS(DBG_C_DEMANGLE))
346 		return (name);
347 
348 	return (conv_demangle_name(name));
349 }
350 
351 const char *
352 Elf_demangle_name(const char *name)
353 {
354 	if (DBG_ISDEMANGLE())
355 		return (conv_demangle_name(name));
356 	return (name);
357 }
358