xref: /titanic_44/usr/src/cmd/sgs/liblddbg/common/files.c (revision fbcec90110655a00a2d5c9bdfaf87c7b476a4902) 
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 2007 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include	<sys/auxv.h>
29 #include	<string.h>
30 #include	<unistd.h>
31 #include	<fcntl.h>
32 #include	<limits.h>
33 #include	<stdio.h>
34 #include	<libld.h>
35 #include	<rtld.h>
36 #include	<conv.h>
37 #include	"msg.h"
38 #include	"_debug.h"
39 
40 void
41 Dbg_file_analyze(Rt_map *lmp)
42 {
43 	Conv_dl_mode_buf_t	dl_mode_buf;
44 	Lm_list			*lml = LIST(lmp);
45 
46 	if (DBG_NOTCLASS(DBG_C_FILES))
47 		return;
48 
49 	Dbg_util_nl(lml, DBG_NL_STD);
50 	dbg_print(lml, MSG_INTL(MSG_FIL_ANALYZE), NAME(lmp),
51 	    conv_dl_mode(MODE(lmp), 1, &dl_mode_buf));
52 }
53 
54 void
55 Dbg_file_aout(Lm_list *lml, const char *name, ulong_t dynamic, ulong_t base,
56     ulong_t size, const char *lmid, Aliste lmco)
57 {
58 	if (DBG_NOTCLASS(DBG_C_FILES))
59 		return;
60 
61 	dbg_print(lml, MSG_INTL(MSG_FIL_AOUT), name);
62 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_DB), EC_XWORD(dynamic),
63 	    EC_ADDR(base));
64 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_S), EC_XWORD(size));
65 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_LL), lmid, EC_XWORD(lmco));
66 }
67 
68 void
69 Dbg_file_elf(Lm_list *lml, const char *name, ulong_t dynamic, ulong_t base,
70     ulong_t size, ulong_t entry, const char *lmid, Aliste lmco)
71 {
72 	const char	*str;
73 
74 	if (DBG_NOTCLASS(DBG_C_FILES))
75 		return;
76 
77 	if (base == 0)
78 		str = MSG_INTL(MSG_STR_TEMPORARY);
79 	else
80 		str = MSG_ORIG(MSG_STR_EMPTY);
81 
82 	dbg_print(lml, MSG_INTL(MSG_FIL_ELF), name, str);
83 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_DB), EC_XWORD(dynamic),
84 	    EC_ADDR(base));
85 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_SE), EC_XWORD(size),
86 	    EC_XWORD(entry));
87 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_LL), lmid, EC_XWORD(lmco));
88 }
89 
90 void
91 Dbg_file_ldso(Rt_map *lmp, char **envp, auxv_t *auxv, const char *lmid,
92     Aliste lmco)
93 {
94 	Lm_list	*lml = LIST(lmp);
95 
96 	if (DBG_NOTCLASS(DBG_C_FILES))
97 		return;
98 
99 	Dbg_util_nl(lml, DBG_NL_STD);
100 	dbg_print(lml, MSG_INTL(MSG_FIL_LDSO), PATHNAME(lmp));
101 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_DB), EC_NATPTR(DYN(lmp)),
102 	    EC_ADDR(ADDR(lmp)));
103 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_EA), EC_NATPTR(envp),
104 	    EC_NATPTR(auxv));
105 	dbg_print(lml, MSG_INTL(MSG_FIL_DATA_LL), lmid, EC_XWORD(lmco));
106 	Dbg_util_nl(lml, DBG_NL_STD);
107 }
108 
109 
110 void
111 Dbg_file_prot(Rt_map *lmp, int prot)
112 {
113 	Lm_list	*lml = LIST(lmp);
114 
115 	if (DBG_NOTCLASS(DBG_C_FILES))
116 		return;
117 
118 	Dbg_util_nl(lml, DBG_NL_STD);
119 	dbg_print(lml, MSG_INTL(MSG_FIL_PROT), NAME(lmp), (prot ? '+' : '-'));
120 }
121 
122 void
123 Dbg_file_delete(Rt_map *lmp)
124 {
125 	Lm_list	*lml = LIST(lmp);
126 
127 	if (DBG_NOTCLASS(DBG_C_FILES))
128 		return;
129 
130 	Dbg_util_nl(lml, DBG_NL_STD);
131 	dbg_print(lml, MSG_INTL(MSG_FIL_DELETE), NAME(lmp));
132 }
133 
134 static int	hdl_title = 0;
135 static Msg	hdl_str = 0;
136 
137 void
138 Dbg_file_hdl_title(int type)
139 {
140 	if (DBG_NOTCLASS(DBG_C_FILES))
141 		return;
142 	if (DBG_NOTDETAIL())
143 		return;
144 
145 	hdl_title = 1;
146 
147 	/*
148 	 * Establish a binding title for later use in Dbg_file_bind_entry.
149 	 * These are to be used with the MSG_INTL() macro.
150 	 *
151 	 * Note: The following are to convince chkmsg.sh that these
152 	 * messages are actually used:
153 	 *
154 	 *	MSG_INTL(MSG_FIL_HDL_CREATE)
155 	 *	MSG_INTL(MSG_FIL_HDL_ADD)
156 	 *	MSG_INTL(MSG_FIL_HDL_DELETE)
157 	 *	MSG_INTL(MSG_FIL_HDL_ORPHAN)
158 	 *	MSG_INTL(MSG_FIL_HDL_REINST)
159 	 */
160 	switch (type) {
161 	case DBG_DEP_CREATE:
162 		hdl_str = MSG_FIL_HDL_CREATE;
163 		break;
164 	case DBG_DEP_ADD:
165 		hdl_str = MSG_FIL_HDL_ADD;
166 		break;
167 	case DBG_DEP_DELETE:
168 		hdl_str = MSG_FIL_HDL_DELETE;
169 		break;
170 	case DBG_DEP_ORPHAN:
171 		hdl_str = MSG_FIL_HDL_ORPHAN;
172 		break;
173 	case DBG_DEP_REINST:
174 		hdl_str = MSG_FIL_HDL_REINST;
175 		break;
176 	default:
177 		hdl_str = 0;
178 		break;
179 	}
180 }
181 
182 void
183 Dbg_file_hdl_collect(Grp_hdl *ghp, const char *name)
184 {
185 	Conv_grphdl_flags_buf_t	grphdl_flags_buf;
186 	Lm_list		*lml = ghp->gh_ownlml;
187 	const char	*str;
188 
189 	if (DBG_NOTCLASS(DBG_C_FILES))
190 		return;
191 	if (DBG_NOTDETAIL())
192 		return;
193 
194 	if (ghp->gh_ownlmp)
195 		str = NAME(ghp->gh_ownlmp);
196 	else
197 		str = MSG_INTL(MSG_STR_ORPHAN);
198 
199 	if (hdl_title) {
200 		hdl_title = 0;
201 		Dbg_util_nl(lml, DBG_NL_STD);
202 	}
203 	if (name)
204 		dbg_print(lml, MSG_INTL(MSG_FIL_HDL_RETAIN), str, name);
205 	else
206 		dbg_print(lml, MSG_INTL(MSG_FIL_HDL_COLLECT), str,
207 		    conv_grphdl_flags(ghp->gh_flags, &grphdl_flags_buf));
208 }
209 
210 void
211 Dbg_file_hdl_action(Grp_hdl *ghp, Rt_map *lmp, int type, uint_t flags)
212 {
213 	Conv_grpdesc_flags_buf_t grpdesc_flags_buf;
214 	const char	*mode, *group;
215 	Lm_list		*lml = LIST(lmp);
216 	Msg		str;
217 
218 	if (DBG_NOTCLASS(DBG_C_FILES))
219 		return;
220 	if (DBG_NOTDETAIL())
221 		return;
222 
223 	if (hdl_title) {
224 		Dbg_util_nl(lml, DBG_NL_STD);
225 		if (hdl_str) {
226 			const char	*name;
227 
228 			/*
229 			 * Protect ourselves in case this handle has no
230 			 * originating owner.
231 			 */
232 			if (ghp->gh_ownlmp)
233 				name = NAME(ghp->gh_ownlmp);
234 			else
235 				name = MSG_INTL(MSG_STR_UNKNOWN);
236 
237 			dbg_print(lml, MSG_INTL(hdl_str), name);
238 		}
239 		hdl_title = 0;
240 	}
241 
242 	/*
243 	 * Note: The following are to convince chkmsg.sh that these
244 	 * messages are actually used:
245 	 *
246 	 *	MSG_INTL(MSG_FIL_DEP_ADD)
247 	 *	MSG_INTL(MSG_FIL_DEP_DELETE)
248 	 *	MSG_INTL(MSG_FIL_DEP_REMOVE)
249 	 *	MSG_INTL(MSG_FIL_DEP_REMAIN)
250 	 *	MSG_INTL(MSG_FIL_DEP_ORPHAN)
251 	 *	MSG_INTL(MSG_FIL_DEP_REINST)
252 	 */
253 	switch (type) {
254 	case DBG_DEP_ADD:
255 		str = MSG_FIL_DEP_ADD;
256 		break;
257 	case DBG_DEP_DELETE:
258 		str = MSG_FIL_DEP_DELETE;
259 		break;
260 	case DBG_DEP_REMOVE:
261 		str = MSG_FIL_DEP_REMOVE;
262 		break;
263 	case DBG_DEP_REMAIN:
264 		str = MSG_FIL_DEP_REMAIN;
265 		break;
266 	case DBG_DEP_ORPHAN:
267 		str = MSG_FIL_DEP_ORPHAN;
268 		break;
269 	case DBG_DEP_REINST:
270 		str = MSG_FIL_DEP_REINST;
271 		break;
272 	default:
273 		return;
274 	}
275 
276 	if ((type == DBG_DEP_ADD) && flags)
277 		group = conv_grpdesc_flags(flags, &grpdesc_flags_buf);
278 	else
279 		group = MSG_ORIG(MSG_STR_EMPTY);
280 
281 	if ((MODE(lmp) & (RTLD_GLOBAL | RTLD_NODELETE)) ==
282 	    (RTLD_GLOBAL | RTLD_NODELETE))
283 		mode = MSG_ORIG(MSG_MODE_GLOBNODEL);
284 	else if (MODE(lmp) & RTLD_GLOBAL)
285 		mode = MSG_ORIG(MSG_MODE_GLOB);
286 
287 	else if (MODE(lmp) & RTLD_NODELETE)
288 		mode = MSG_ORIG(MSG_MODE_NODEL);
289 	else
290 		mode = MSG_ORIG(MSG_STR_EMPTY);
291 
292 	dbg_print(lml, MSG_INTL(str), NAME(lmp), mode, group);
293 }
294 
295 void
296 Dbg_file_bind_entry(Lm_list *lml, Bnd_desc *bdp)
297 {
298 	Conv_bnd_type_buf_t bnd_type_buf;
299 
300 	if (DBG_NOTCLASS(DBG_C_FILES))
301 		return;
302 	if (DBG_NOTDETAIL())
303 		return;
304 
305 	/*
306 	 * Print the dependency together with the modes of the binding.
307 	 */
308 	Dbg_util_nl(lml, DBG_NL_STD);
309 	dbg_print(lml, MSG_INTL(MSG_FIL_BND_ADD), NAME(bdp->b_caller));
310 	dbg_print(lml, MSG_INTL(MSG_FIL_BND_FILE), NAME(bdp->b_depend),
311 	    conv_bnd_type(bdp->b_flags, &bnd_type_buf));
312 }
313 
314 void
315 Dbg_file_bindings(Rt_map *lmp, int flag)
316 {
317 	Conv_bnd_obj_buf_t	bnd_obj_buf;
318 	Conv_bnd_type_buf_t	bnd_type_buf;
319 	const char	*str;
320 	Rt_map		*tlmp;
321 	Lm_list		*lml = LIST(lmp);
322 	int		next = 0;
323 
324 	if (DBG_NOTCLASS(DBG_C_INIT))
325 		return;
326 	if (DBG_NOTDETAIL())
327 		return;
328 
329 	if (flag & RT_SORT_REV)
330 		str = MSG_ORIG(MSG_SCN_INIT);
331 	else
332 		str = MSG_ORIG(MSG_SCN_FINI);
333 
334 	Dbg_util_nl(lml, DBG_NL_STD);
335 	dbg_print(lml, MSG_INTL(MSG_FIL_DEP_TITLE), str,
336 	    conv_bnd_obj(lml->lm_flags, &bnd_obj_buf));
337 
338 	/* LINTED */
339 	for (tlmp = lmp; tlmp; tlmp = (Rt_map *)NEXT(tlmp)) {
340 		Bnd_desc	**bdpp;
341 		Aliste		off;
342 
343 		/*
344 		 * For .init processing, only collect objects that have been
345 		 * relocated and haven't already been collected.
346 		 * For .fini processing, only collect objects that have had
347 		 * their .init collected, and haven't already been .fini
348 		 * collected.
349 		 */
350 		if (flag & RT_SORT_REV) {
351 			if ((FLAGS(tlmp) & (FLG_RT_RELOCED |
352 			    FLG_RT_INITCLCT)) != FLG_RT_RELOCED)
353 				continue;
354 
355 		} else {
356 			if ((flag & RT_SORT_DELETE) &&
357 			    ((FLAGS(tlmp) & FLG_RT_DELETE) == 0))
358 				continue;
359 			if (((FLAGS(tlmp) &
360 			    (FLG_RT_INITCLCT | FLG_RT_FINICLCT)) ==
361 			    FLG_RT_INITCLCT) == 0)
362 				continue;
363 		}
364 
365 		if (next++)
366 			Dbg_util_nl(lml, DBG_NL_STD);
367 
368 		if (DEPENDS(tlmp) == 0)
369 			dbg_print(lml, MSG_INTL(MSG_FIL_DEP_NONE), NAME(tlmp));
370 		else {
371 			dbg_print(lml, MSG_INTL(MSG_FIL_DEP_ENT), NAME(tlmp));
372 
373 			for (ALIST_TRAVERSE(DEPENDS(tlmp), off, bdpp)) {
374 				dbg_print(lml, MSG_INTL(MSG_FIL_BND_FILE),
375 				    NAME((*bdpp)->b_depend),
376 				    conv_bnd_type((*bdpp)->b_flags,
377 				    &bnd_type_buf));
378 			}
379 		}
380 	}
381 	Dbg_util_nl(lml, DBG_NL_STD);
382 }
383 
384 void
385 Dbg_file_dlopen(Rt_map *clmp, const char *name, int mode)
386 {
387 	Conv_dl_mode_buf_t	dl_mode_buf;
388 	Lm_list			*lml = LIST(clmp);
389 
390 	if (DBG_NOTCLASS(DBG_C_FILES))
391 		return;
392 
393 	Dbg_util_nl(lml, DBG_NL_STD);
394 	dbg_print(lml, MSG_INTL(MSG_FIL_DLOPEN), name, NAME(clmp),
395 	    conv_dl_mode(mode, 1, &dl_mode_buf));
396 }
397 
398 void
399 Dbg_file_dlclose(Lm_list *lml, const char *name, int flag)
400 {
401 	const char	*str;
402 
403 	if (DBG_NOTCLASS(DBG_C_FILES))
404 		return;
405 
406 	if (flag == DBG_DLCLOSE_IGNORE)
407 		str = MSG_INTL(MSG_STR_IGNORE);
408 	else
409 		str = MSG_ORIG(MSG_STR_EMPTY);
410 
411 	Dbg_util_nl(lml, DBG_NL_STD);
412 	dbg_print(lml, MSG_INTL(MSG_FIL_DLCLOSE), name, str);
413 }
414 
415 void
416 Dbg_file_dldump(Rt_map *lmp, const char *path, int flags)
417 {
418 	Conv_dl_flag_buf_t	dl_flag_buf;
419 	Lm_list			*lml = LIST(lmp);
420 
421 	if (DBG_NOTCLASS(DBG_C_FILES))
422 		return;
423 
424 	Dbg_util_nl(lml, DBG_NL_STD);
425 	dbg_print(lml, MSG_INTL(MSG_FIL_DLDUMP), NAME(lmp), path,
426 	    conv_dl_flag(flags, 0, &dl_flag_buf));
427 }
428 
429 void
430 Dbg_file_lazyload(Rt_map *clmp, const char *fname, const char *sname)
431 {
432 	Lm_list	*lml = LIST(clmp);
433 
434 	if (DBG_NOTCLASS(DBG_C_FILES))
435 		return;
436 
437 	Dbg_util_nl(lml, DBG_NL_STD);
438 	dbg_print(lml, MSG_INTL(MSG_FIL_LAZYLOAD), fname, NAME(clmp),
439 	    Dbg_demangle_name(sname));
440 }
441 
442 void
443 Dbg_file_preload(Lm_list *lml, const char *name)
444 {
445 	if (DBG_NOTCLASS(DBG_C_FILES))
446 		return;
447 
448 	Dbg_util_nl(lml, DBG_NL_STD);
449 	dbg_print(lml, MSG_INTL(MSG_FIL_PRELOAD), name);
450 }
451 
452 void
453 Dbg_file_needed(Rt_map *lmp, const char *name)
454 {
455 	Lm_list	*lml = LIST(lmp);
456 
457 	if (DBG_NOTCLASS(DBG_C_FILES))
458 		return;
459 
460 	Dbg_util_nl(lml, DBG_NL_STD);
461 	dbg_print(lml, MSG_INTL(MSG_FIL_NEEDED), name, NAME(lmp));
462 }
463 
464 void
465 Dbg_file_filter(Lm_list *lml, const char *filter, const char *filtee,
466     int config)
467 {
468 	if (DBG_NOTCLASS(DBG_C_FILES))
469 		return;
470 
471 	Dbg_util_nl(lml, DBG_NL_STD);
472 	if (config)
473 		dbg_print(lml, MSG_INTL(MSG_FIL_FILTER_1), filter, filtee);
474 	else
475 		dbg_print(lml, MSG_INTL(MSG_FIL_FILTER_2), filter, filtee);
476 }
477 
478 void
479 Dbg_file_filtee(Lm_list *lml, const char *filter, const char *filtee, int audit)
480 {
481 	if (audit) {
482 		if (DBG_NOTCLASS(DBG_C_AUDITING | DBG_C_FILES))
483 			return;
484 
485 		Dbg_util_nl(lml, DBG_NL_STD);
486 		dbg_print(lml, MSG_INTL(MSG_FIL_FILTEE_3), filtee);
487 	} else {
488 		if (DBG_NOTCLASS(DBG_C_FILES))
489 			return;
490 
491 		Dbg_util_nl(lml, DBG_NL_STD);
492 		if (filter)
493 			dbg_print(lml, MSG_INTL(MSG_FIL_FILTEE_1), filtee,
494 			    filter);
495 		else
496 			dbg_print(lml, MSG_INTL(MSG_FIL_FILTEE_2), filtee);
497 	}
498 }
499 
500 void
501 Dbg_file_fixname(Lm_list *lml, const char *oname, const char *nname)
502 {
503 	if (DBG_NOTCLASS(DBG_C_FILES))
504 		return;
505 
506 	Dbg_util_nl(lml, DBG_NL_STD);
507 	dbg_print(lml, MSG_INTL(MSG_FIL_FIXNAME), oname, nname);
508 }
509 
510 void
511 Dbg_file_output(Ofl_desc *ofl)
512 {
513 	const char	*prefix = MSG_ORIG(MSG_PTH_OBJECT);
514 	char		*oname, *nname, *ofile;
515 	int		fd;
516 
517 	if (DBG_NOTCLASS(DBG_C_FILES))
518 		return;
519 	if (DBG_NOTDETAIL())
520 		return;
521 
522 	/*
523 	 * Obtain the present input object filename for concatenation to the
524 	 * prefix name.
525 	 */
526 	oname = (char *)ofl->ofl_name;
527 	if ((ofile = strrchr(oname, '/')) == NULL)
528 		ofile = oname;
529 	else
530 		ofile++;
531 
532 	/*
533 	 * Concatenate the prefix with the object filename, open the file and
534 	 * write out the present Elf memory image.  As this is debugging we
535 	 * ignore all errors.
536 	 */
537 	if ((nname = malloc(strlen(prefix) + strlen(ofile) + 1)) != 0) {
538 		(void) strcpy(nname, prefix);
539 		(void) strcat(nname, ofile);
540 		if ((fd = open(nname, O_RDWR | O_CREAT | O_TRUNC,
541 		    0666)) != -1) {
542 			(void) write(fd, ofl->ofl_nehdr, ofl->ofl_size);
543 			(void) close(fd);
544 		}
545 		free(nname);
546 	}
547 }
548 
549 void
550 Dbg_file_config_dis(Lm_list *lml, const char *config, int features)
551 {
552 	Conv_config_feat_buf_t	config_feat_buf;
553 	const char		*str;
554 
555 	switch (features & ~CONF_FEATMSK) {
556 	case DBG_CONF_IGNORE:
557 		str = MSG_INTL(MSG_FIL_CONFIG_ERR_1);
558 		break;
559 	case DBG_CONF_VERSION:
560 		str = MSG_INTL(MSG_FIL_CONFIG_ERR_2);
561 		break;
562 	case DBG_CONF_PRCFAIL:
563 		str = MSG_INTL(MSG_FIL_CONFIG_ERR_3);
564 		break;
565 	case DBG_CONF_CORRUPT:
566 		str = MSG_INTL(MSG_FIL_CONFIG_ERR_4);
567 		break;
568 	case DBG_CONF_ABIMISMATCH:
569 		str = MSG_INTL(MSG_FIL_CONFIG_ERR_5);
570 		break;
571 	default:
572 		str = conv_config_feat(features, &config_feat_buf);
573 		break;
574 	}
575 
576 	Dbg_util_nl(lml, DBG_NL_FRC);
577 	dbg_print(lml, MSG_INTL(MSG_FIL_CONFIG_ERR), config, str);
578 	Dbg_util_nl(lml, DBG_NL_FRC);
579 }
580 
581 void
582 Dbg_file_config_obj(Lm_list *lml, const char *dir, const char *file,
583     const char *config)
584 {
585 	char	*name, _name[PATH_MAX];
586 
587 	if (DBG_NOTCLASS(DBG_C_FILES))
588 		return;
589 
590 	if (file) {
591 		(void) snprintf(_name, PATH_MAX, MSG_ORIG(MSG_FMT_PATH),
592 		    dir, file);
593 		name = _name;
594 	} else
595 		name = (char *)dir;
596 
597 	dbg_print(lml, MSG_INTL(MSG_FIL_CONFIG), name, config);
598 }
599 
600 void
601 Dbg_file_del_rescan(Lm_list *lml)
602 {
603 	if (DBG_NOTCLASS(DBG_C_FILES))
604 		return;
605 
606 	Dbg_util_nl(lml, DBG_NL_STD);
607 	dbg_print(lml, MSG_INTL(MSG_FIL_DEL_RESCAN));
608 }
609 
610 void
611 Dbg_file_mode_promote(Rt_map *lmp, int mode)
612 {
613 	Conv_dl_mode_buf_t	dl_mode_buf;
614 	Lm_list			*lml = LIST(lmp);
615 
616 	if (DBG_NOTCLASS(DBG_C_FILES))
617 		return;
618 
619 	Dbg_util_nl(lml, DBG_NL_STD);
620 	dbg_print(lml, MSG_INTL(MSG_FIL_PROMOTE), NAME(lmp),
621 	    conv_dl_mode(mode, 0, &dl_mode_buf));
622 	Dbg_util_nl(lml, DBG_NL_STD);
623 }
624 
625 void
626 Dbg_file_cntl(Lm_list *lml, Aliste flmco, Aliste tlmco)
627 {
628 	Lm_cntl	*lmc;
629 	Aliste	off;
630 
631 	if (DBG_NOTCLASS(DBG_C_FILES))
632 		return;
633 	if (DBG_NOTDETAIL())
634 		return;
635 
636 	Dbg_util_nl(lml, DBG_NL_STD);
637 	dbg_print(lml, MSG_INTL(MSG_CNTL_TITLE), EC_XWORD(flmco),
638 	    EC_XWORD(tlmco));
639 
640 	for (ALIST_TRAVERSE(lml->lm_lists, off, lmc)) {
641 		Rt_map	*lmp;
642 
643 		/* LINTED */
644 		for (lmp = lmc->lc_head; lmp; lmp = (Rt_map *)NEXT(lmp))
645 			dbg_print(lml, MSG_ORIG(MSG_CNTL_ENTRY), EC_XWORD(off),
646 			    NAME(lmp));
647 	}
648 	Dbg_util_nl(lml, DBG_NL_STD);
649 }
650 
651 void
652 Dbg_file_ar_rescan(Lm_list *lml)
653 {
654 	if (DBG_NOTCLASS(DBG_C_FILES))
655 		return;
656 
657 	Dbg_util_nl(lml, DBG_NL_STD);
658 	dbg_print(lml, MSG_INTL(MSG_FIL_AR_RESCAN));
659 	Dbg_util_nl(lml, DBG_NL_STD);
660 }
661 
662 void
663 Dbg_file_ar(Lm_list *lml, const char *name, int again)
664 {
665 	const char	*str;
666 
667 	if (DBG_NOTCLASS(DBG_C_FILES))
668 		return;
669 
670 	if (again)
671 		str = MSG_INTL(MSG_STR_AGAIN);
672 	else
673 		str = MSG_ORIG(MSG_STR_EMPTY);
674 
675 	Dbg_util_nl(lml, DBG_NL_STD);
676 	dbg_print(lml, MSG_INTL(MSG_FIL_ARCHIVE), name, str);
677 }
678 
679 void
680 Dbg_file_generic(Lm_list *lml, Ifl_desc *ifl)
681 {
682 	Conv_inv_buf_t inv_buf;
683 
684 	if (DBG_NOTCLASS(DBG_C_FILES))
685 		return;
686 
687 	Dbg_util_nl(lml, DBG_NL_STD);
688 	dbg_print(lml, MSG_INTL(MSG_FIL_BASIC), ifl->ifl_name,
689 	    conv_ehdr_type(ifl->ifl_ehdr->e_type, 0, &inv_buf));
690 }
691 
692 static const Msg
693 reject[] = {
694 	MSG_STR_EMPTY,
695 	MSG_REJ_MACH,		/* MSG_INTL(MSG_REJ_MACH) */
696 	MSG_REJ_CLASS,		/* MSG_INTL(MSG_REJ_CLASS) */
697 	MSG_REJ_DATA,		/* MSG_INTL(MSG_REJ_DATA) */
698 	MSG_REJ_TYPE,		/* MSG_INTL(MSG_REJ_TYPE) */
699 	MSG_REJ_BADFLAG,	/* MSG_INTL(MSG_REJ_BADFLAG) */
700 	MSG_REJ_MISFLAG,	/* MSG_INTL(MSG_REJ_MISFLAG) */
701 	MSG_REJ_VERSION,	/* MSG_INTL(MSG_REJ_VERSION) */
702 	MSG_REJ_HAL,		/* MSG_INTL(MSG_REJ_HAL) */
703 	MSG_REJ_US3,		/* MSG_INTL(MSG_REJ_US3) */
704 	MSG_REJ_STR,		/* MSG_INTL(MSG_REJ_STR) */
705 	MSG_REJ_UNKFILE,	/* MSG_INTL(MSG_REJ_UNKFILE) */
706 	MSG_REJ_HWCAP_1,	/* MSG_INTL(MSG_REJ_HWCAP_1) */
707 };
708 
709 void
710 Dbg_file_rejected(Lm_list *lml, Rej_desc *rej)
711 {
712 	Conv_reject_desc_buf_t rej_buf;
713 
714 	if (DBG_NOTCLASS(DBG_C_FILES))
715 		return;
716 
717 	Dbg_util_nl(lml, DBG_NL_STD);
718 	dbg_print(lml, MSG_INTL(reject[rej->rej_type]), rej->rej_name ?
719 	    rej->rej_name : MSG_INTL(MSG_STR_UNKNOWN),
720 	    conv_reject_desc(rej, &rej_buf));
721 	Dbg_util_nl(lml, DBG_NL_STD);
722 }
723 
724 void
725 Dbg_file_reuse(Lm_list *lml, const char *nname, const char *oname)
726 {
727 	if (DBG_NOTCLASS(DBG_C_FILES))
728 		return;
729 
730 	dbg_print(lml, MSG_INTL(MSG_FIL_REUSE), nname, oname);
731 }
732 
733 void
734 Dbg_file_skip(Lm_list *lml, const char *oname, const char *nname)
735 {
736 	if (DBG_NOTCLASS(DBG_C_FILES))
737 		return;
738 
739 	if (oname && strcmp(nname, oname))
740 		dbg_print(lml, MSG_INTL(MSG_FIL_SKIP_1), nname, oname);
741 	else
742 		dbg_print(lml, MSG_INTL(MSG_FIL_SKIP_2), nname);
743 }
744 
745 void
746 Dbg_file_modified(Lm_list *lml, const char *obj, const char *oname,
747     const char *nname, int ofd, int nfd, Elf *oelf, Elf *nelf)
748 {
749 	const char	*str;
750 
751 	if (DBG_NOTCLASS(DBG_C_FILES | DBG_C_SUPPORT))
752 		return;
753 	if (DBG_NOTDETAIL())
754 		return;
755 
756 	Dbg_util_nl(lml, DBG_NL_STD);
757 	dbg_print(lml, MSG_INTL(MSG_FIL_MODIFIED), oname, obj);
758 
759 	if (nname != oname)
760 		dbg_print(lml, MSG_INTL(MSG_FIL_NAMECHANGE), nname);
761 	if (nfd != ofd) {
762 		if (nfd == -1)
763 			str = MSG_INTL(MSG_FIL_IGNORE);
764 		else
765 			str = MSG_ORIG(MSG_STR_EMPTY);
766 		dbg_print(lml, MSG_INTL(MSG_FIL_FDCHANGE), ofd, nfd, str);
767 	}
768 	if (nelf != oelf) {
769 		if (nelf == 0)
770 			str = MSG_INTL(MSG_FIL_IGNORE);
771 		else
772 			str = MSG_ORIG(MSG_STR_EMPTY);
773 		dbg_print(lml, MSG_INTL(MSG_FIL_ELFCHANGE), EC_NATPTR(oelf),
774 		    EC_NATPTR(nelf), str);
775 	}
776 	Dbg_util_nl(lml, DBG_NL_STD);
777 }
778 
779 void
780 Dbg_file_cleanup(Lm_list *lml, const char *name, Aliste lmco)
781 {
782 	if (DBG_NOTCLASS(DBG_C_FILES))
783 		return;
784 
785 	Dbg_util_nl(lml, DBG_NL_STD);
786 	dbg_print(lml, MSG_INTL(MSG_FIL_CLEANUP), name, EC_XWORD(lmco));
787 }
788