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