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 }