void
Dbg_util_edge_in(Lm_list *lml, Rt_map *clmp, uint_t flags, Rt_map *dlmp,
int ndx, int flag)
{
const char *str;
if (DBG_NOTCLASS(DBG_C_INIT))
return;
if (DBG_NOTDETAIL())
return;
if (flag & RT_SORT_REV)
str = MSG_ORIG(MSG_SCN_INIT);
else
str = MSG_ORIG(MSG_SCN_FINI);
if ((clmp == 0) || (ectoggle == 0))
Dbg_util_nl(lml, DBG_NL_STD);
if (clmp == 0) {
dbg_print(lml, MSG_INTL(MSG_UTL_EDGE_TITLE), str);
dbg_print(lml, MSG_INTL(MSG_UTL_EDGE_START), ndx, NAME(dlmp));
} else
dbg_print(lml, MSG_INTL(MSG_UTL_EDGE_IN), ndx, NAME(dlmp),
NAME(clmp), conv_bnd_type(flags));
ectoggle = 1;
}
void
Dbg_support_action(Lm_list *lml, const char *obj, const char *func,
Support_ndx ndx, const char *name)
{
const char *str;
if (DBG_NOTCLASS(DBG_C_SUPPORT))
return;
if (DBG_NOTDETAIL())
return;
if (ndx == LDS_START)
str = MSG_INTL(MSG_SUP_OUTFILE);
else if (ndx == LDS_FILE)
str = MSG_INTL(MSG_SUP_INFILE);
else if (ndx == LDS_INP_SECTION)
str = MSG_INTL(MSG_SUP_INSEC);
else if (ndx == LDS_SECTION)
str = MSG_INTL(MSG_SUP_SEC);
if ((ndx == LDS_ATEXIT) || (ndx == LDS_VERSION) ||
(ndx == LDS_INPUT_DONE))
dbg_print(lml, MSG_INTL(MSG_SUP_CALLING_1), func, obj);
else
dbg_print(lml, MSG_INTL(MSG_SUP_CALLING_2), func, obj,
str, name);
}
void
Dbg_unused_sec(Lm_list *lml, Is_desc *isp)
{
const char *str;
if (DBG_NOTCLASS(DBG_C_UNUSED))
return;
if (DBG_NOTDETAIL())
return;
/*
* If the file from which this section originates hasn't been referenced
* at all, skip this diagnostic, as it would have been covered under
* Dbg_unused_file() called from ignore_section_processing().
*/
if (isp->is_file &&
((isp->is_file->ifl_flags & FLG_IF_FILEREF) == 0))
return;
if (isp->is_flags & FLG_IS_DISCARD)
str = MSG_INTL(MSG_USD_SECDISCARD);
else
str = MSG_ORIG(MSG_STR_EMPTY);
dbg_print(lml, MSG_INTL(MSG_USD_SEC), isp->is_basename,
EC_XWORD(isp->is_shdr->sh_size), isp->is_file->ifl_name, str);
}
void
Dbg_util_scc_entry(Rt_map *lmp, uint_t idx)
{
if (DBG_NOTCLASS(DBG_C_INIT))
return;
if (DBG_NOTDETAIL())
return;
dbg_print(LIST(lmp), MSG_ORIG(MSG_UTL_SCC_ENTRY), idx, NAME(lmp));
}
void
Dbg_unused_unref(Rt_map *lmp, const char *depend)
{
if (DBG_NOTCLASS(DBG_C_UNUSED))
return;
if (DBG_NOTDETAIL())
return;
dbg_print(LIST(lmp), MSG_INTL(MSG_USD_UNREF), NAME(lmp), depend);
}
void
Dbg_util_edge_out(Rt_map *clmp, Rt_map *dlmp)
{
if (DBG_NOTCLASS(DBG_C_INIT))
return;
if (DBG_NOTDETAIL())
return;
dbg_print(LIST(clmp), MSG_INTL(MSG_UTL_EDGE_OUT), SORTVAL(clmp),
NAME(clmp), NAME(dlmp));
}
void
Dbg_sec_strtab(Lm_list *lml, Os_desc *osp, Str_tbl *stp)
{
uint_t cnt;
if (DBG_NOTCLASS(DBG_C_STRTAB))
return;
if (!osp)
return;
Dbg_util_nl(lml, DBG_NL_STD);
if (stp->st_flags & FLG_STTAB_COMPRESS)
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_COMP), osp->os_name,
EC_XWORD(stp->st_fullstrsize), EC_XWORD(stp->st_strsize));
else
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_STND), osp->os_name,
EC_XWORD(stp->st_fullstrsize));
if ((DBG_NOTDETAIL()) ||
((stp->st_flags & FLG_STTAB_COMPRESS) == 0))
return;
dbg_print(lml, MSG_ORIG(MSG_STR_EMPTY));
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_HD), osp->os_name,
stp->st_hbckcnt);
for (cnt = 0; cnt < stp->st_hbckcnt; cnt++) {
Str_hash *strhash = stp->st_hashbcks[cnt];
if (strhash == NULL)
continue;
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_BCKT), cnt);
while (strhash) {
size_t stroff = strhash->hi_mstr->sm_strlen -
strhash->hi_strlen;
if (stroff == 0) {
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_MSTR),
EC_XWORD(strhash->hi_refcnt),
strhash->hi_mstr->sm_str);
} else {
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_SUFSTR),
EC_XWORD(strhash->hi_refcnt),
&strhash->hi_mstr->sm_str[stroff],
strhash->hi_mstr->sm_str);
}
strhash = strhash->hi_next;
}
}
}
void
Dbg_move_expand(Lm_list *lml, Move *mv, Addr addr)
{
if (DBG_NOTCLASS(DBG_C_MOVE))
return;
if (DBG_NOTDETAIL())
return;
dbg_print(lml, MSG_INTL(MSG_MOVE_EXPAND), EC_ADDR(addr),
EC_LWORD(mv->m_value));
}
void
Dbg_move_adjexpandreloc(Lm_list *lml, Xword offset, const char *name)
{
if (DBG_NOTCLASS(DBG_C_MOVE | DBG_C_RELOC))
return;
if (DBG_NOTDETAIL())
return;
dbg_print(lml, MSG_INTL(MSG_MOVE_ADJEXPAND), Dbg_demangle_name(name),
EC_XWORD(offset));
}
void
Dbg_move_outsctadj(Lm_list *lml, Sym_desc *sdp)
{
if (DBG_NOTCLASS(DBG_C_MOVE | DBG_C_RELOC))
return;
if (DBG_NOTDETAIL())
return;
dbg_print(lml, MSG_INTL(MSG_MOVE_OUTSCTADJ),
Dbg_demangle_name(sdp->sd_name));
}
void
Dbg_move_outmove(Lm_list *lml, const char *name)
{
if (DBG_NOTCLASS(DBG_C_MOVE))
return;
if (DBG_NOTDETAIL())
return;
Dbg_util_nl(lml, DBG_NL_STD);
dbg_print(lml, MSG_INTL(MSG_MOVE_OUTMOVE), name);
dbg_print(lml, MSG_INTL(MSG_MOVE_TITLE1));
}
void
Dbg_move_parexpn(Lm_list *lml, const char *name, const char *reason)
{
if (DBG_NOTCLASS(DBG_C_MOVE))
return;
if (DBG_NOTDETAIL())
return;
Dbg_util_nl(lml, DBG_NL_STD);
dbg_print(lml, MSG_INTL(MSG_MOVE_PAREXPN), name, reason);
dbg_print(lml, MSG_INTL(MSG_MOVE_TITLE1));
}
void
Dbg_move_data(Rt_map *lmp)
{
Lm_list *lml = LIST(lmp);
if (DBG_NOTCLASS(DBG_C_MOVE))
return;
if (DBG_NOTDETAIL())
return;
dbg_print(lml, MSG_INTL(MSG_MOVE_FILE), NAME(lmp));
dbg_print(lml, MSG_INTL(MSG_MOVE_TITLE2));
}
void
Dbg_util_broadcast(Rt_map *lmp)
{
Lm_list *lml = LIST(lmp);
if (DBG_NOTCLASS(DBG_C_INIT))
return;
if (DBG_NOTDETAIL())
return;
Dbg_util_nl(lml, DBG_NL_STD);
dbg_print(lml, MSG_INTL(MSG_UTL_BROAD), NAME(lmp));
Dbg_util_nl(lml, DBG_NL_STD);
}
void
Dbg_sec_strtab(Lm_list *lml, Os_desc *osp, Str_tbl *stp)
{
uint_t i;
if (DBG_NOTCLASS(DBG_C_STRTAB))
return;
if (!osp)
return;
Dbg_util_nl(lml, DBG_NL_STD);
if (stp->st_flags & FLG_STTAB_COMPRESS)
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_COMP), osp->os_name,
stp->st_fullstringsize, stp->st_stringsize);
else
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_STND), osp->os_name,
stp->st_fullstringsize);
if ((DBG_NOTDETAIL()) ||
((stp->st_flags & FLG_STTAB_COMPRESS) == 0))
return;
dbg_print(lml, MSG_ORIG(MSG_STR_EMPTY));
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_HD), osp->os_name,
stp->st_hbckcnt);
for (i = 0; i < stp->st_hbckcnt; i++) {
Str_hash *sthash;
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_BCKT), i);
for (sthash = stp->st_hashbcks[i]; sthash;
sthash = sthash->hi_next) {
uint_t stroff = sthash->hi_mstr->sm_stlen -
sthash->hi_stlen;
if (stroff == 0) {
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_MSTR),
sthash->hi_refcnt, sthash->hi_mstr->sm_str);
} else {
dbg_print(lml, MSG_INTL(MSG_SEC_STRTAB_SUFSTR),
sthash->hi_refcnt,
&sthash->hi_mstr->sm_str[stroff],
sthash->hi_mstr->sm_str);
}
}
}
}
void
Dbg_util_dbnotify(Lm_list *lml, rd_event_e event, r_state_e state)
{
const char *estr;
const char *sstr;
if (DBG_NOTCLASS(DBG_C_FILES))
return;
if (DBG_NOTDETAIL())
return;
switch (event) {
case RD_PREINIT:
estr = MSG_ORIG(MSG_UTL_EVNT_PREINIT);
sstr = MSG_INTL(MSG_STR_NULL);
break;
case RD_POSTINIT:
estr = MSG_ORIG(MSG_UTL_EVNT_POSTINIT);
sstr = MSG_INTL(MSG_STR_NULL);
break;
case RD_DLACTIVITY:
estr = MSG_ORIG(MSG_UTL_EVNT_DLACT);
switch (state) {
case RT_CONSISTENT:
sstr = MSG_ORIG(MSG_UTL_STA_CONSIST);
break;
case RT_ADD:
sstr = MSG_ORIG(MSG_UTL_STA_ADD);
break;
case RT_DELETE:
sstr = MSG_ORIG(MSG_UTL_STA_DELETE);
break;
default:
sstr = MSG_INTL(MSG_STR_NULL);
break;
}
break;
default:
sstr = MSG_INTL(MSG_STR_NULL);
estr = MSG_INTL(MSG_STR_UNKNOWN);
break;
}
Dbg_util_nl(lml, DBG_NL_STD);
dbg_print(lml, MSG_INTL(MSG_UTL_DBNOTIFY), estr, sstr);
Dbg_util_nl(lml, DBG_NL_STD);
}
void
Dbg_sec_order_error(Lm_list *lml, Ifl_desc *ifl, Word ndx, int error)
{
if (DBG_NOTCLASS(DBG_C_SECTIONS))
return;
if (DBG_NOTDETAIL())
return;
if (error == 0)
return;
dbg_print(lml, MSG_INTL(MSG_ORD_ERR_TITLE),
ifl->ifl_isdesc[ndx]->is_name, ifl->ifl_name);
if (error)
dbg_print(lml, MSG_INTL(order_errors[error - 1]));
}
void
Dbg_util_lcinterface(Rt_map *lmp, int tag, char *val)
{
const char *str;
static char string[CONV_INV_STRSIZE];
if (DBG_NOTDETAIL())
return;
if (tag < CI_MAX)
str = MSG_ORIG(tags[tag]);
else
str = conv_invalid_val(string, CONV_INV_STRSIZE, tag, 0);
dbg_print(LIST(lmp), MSG_INTL(MSG_UTL_LCINTERFACE), NAME(lmp), str,
EC_NATPTR(val));
}
void
Dbg_move_entry1(Lm_list *lml, int which, Move *mv, Sym_desc *s)
{
const char *str;
if (DBG_NOTCLASS(DBG_C_MOVE))
return;
if (DBG_NOTDETAIL())
return;
if (which)
str = MSG_INTL(MSG_MOVE_ENTRYIN);
else
str = MSG_INTL(MSG_MOVE_ENTRYOUT);
dbg_print(lml, str, EC_XWORD(mv->m_poffset), EC_LWORD(mv->m_value),
mv->m_repeat, mv->m_stride, s->sd_name);
}
void
Dbg_move_entry2(Lm_list *lml, Move *mv, Word st_name, const char *name)
{
const char *sname;
if (DBG_NOTCLASS(DBG_C_MOVE))
return;
if (DBG_NOTDETAIL())
return;
if (st_name)
sname = name;
else
sname = MSG_INTL(MSG_STR_UNKNOWN);
dbg_print(lml, MSG_INTL(MSG_MOVE_ENTRYIN), EC_XWORD(mv->m_poffset),
EC_LWORD(mv->m_value), mv->m_repeat, mv->m_stride, sname);
}
void
Dbg_util_scc_title(Lm_list *lml, int sec)
{
const char *_sec;
if (DBG_NOTCLASS(DBG_C_INIT))
return;
if (DBG_NOTDETAIL())
return;
if (sec)
_sec = MSG_INTL(MSG_UTL_SCC_SUBI);
else
_sec = MSG_INTL(MSG_UTL_SCC_SUBF);
Dbg_util_nl(lml, DBG_NL_STD);
dbg_print(lml, MSG_INTL(MSG_UTL_SCC_TITLE), _sec);
}
void
Dbg_audit_symval(Lm_list *lml, const char *lib, const char *func,
const char *sym, Addr pval, Addr nval)
{
char mesg[100];
if (DBG_NOTCLASS(DBG_C_AUDITING))
return;
if (DBG_NOTDETAIL())
return;
if (pval == nval)
mesg[0] = '\0';
else
(void) sprintf(mesg, MSG_INTL(MSG_AUD_SYMNEW), EC_XWORD(nval));
dbg_print(lml, MSG_INTL(MSG_AUD_SYM), lib, func, Dbg_demangle_name(sym),
EC_XWORD(pval), mesg);
}
void
Dbg_util_wait(Rt_map *clmp, Rt_map *dlmp, int what)
{
Lm_list *lml = LIST(clmp);
const char *str;
if (DBG_NOTCLASS(DBG_C_INIT))
return;
if (DBG_NOTDETAIL())
return;
if (what == DBG_WAIT_INIT)
str = MSG_ORIG(MSG_SCN_INIT);
else if (what == DBG_WAIT_FINI)
str = MSG_ORIG(MSG_SCN_FINI);
else
str = MSG_INTL(MSG_STR_SYMBOL);
Dbg_util_nl(lml, DBG_NL_STD);
dbg_print(lml, MSG_INTL(MSG_UTL_WAIT), str, NAME(clmp), NAME(dlmp));
Dbg_util_nl(lml, DBG_NL_STD);
}
void
Dbg_util_collect(Rt_map *lmp, int ndx, int flag)
{
Lm_list *lml = LIST(lmp);
const char *str;
if (DBG_NOTCLASS(DBG_C_INIT))
return;
if (DBG_NOTDETAIL())
return;
if (flag & RT_SORT_REV)
str = MSG_ORIG(MSG_SCN_INIT);
else
str = MSG_ORIG(MSG_SCN_FINI);
if (ectoggle == 1) {
Dbg_util_nl(lml, DBG_NL_STD);
ectoggle = 0;
}
dbg_print(lml, MSG_INTL(MSG_UTL_COLLECT), ndx, NAME(lmp), str);
}
void
Dbg_got_display(Ofl_desc *ofl, Off goff, int stage,
Word m_got_xnumber, size_t m_got_entsize)
{
Lm_list *lml = ofl->ofl_lml;
Gottable *gtp = ofl->ofl_gottable;
Word gotndx;
Xword *gptr;
if (DBG_NOTCLASS(DBG_C_GOT))
return;
if (ofl->ofl_gotcnt == m_got_xnumber)
return;
Dbg_util_nl(lml, DBG_NL_STD);
dbg_print(lml, MSG_INTL(MSG_GOT_INFO), EC_WORD(ofl->ofl_gotcnt));
if (DBG_NOTDETAIL())
return;
qsort((char *)gtp, ofl->ofl_gotcnt, sizeof (Gottable),
(int(*)(const void *, const void *))Dbg_got_compare);
if (stage == 0)
dbg_print(lml, MSG_INTL(MSG_GOT_COLUMNS1));
else
dbg_print(lml, MSG_INTL(MSG_GOT_COLUMNS2));
gptr = (Xword *)ofl->ofl_osgot->os_outdata->d_buf;
for (gotndx = 0; gotndx < ofl->ofl_gotcnt; gotndx++, gtp++, gptr++) {
Sym_desc *sdp = gtp->gt_sym;
const char *refstr, *name;
Gotndx *gnp = >p->gt_gndx;
Lword gotaddval;
Off off = goff + (gotndx * m_got_entsize);
char index[INDEX_STR_SIZE];
(void) snprintf(index, INDEX_STR_SIZE, MSG_ORIG(MSG_GOT_INDEX),
EC_SWORD(gnp->gn_gotndx));
if (sdp == 0)
refstr = MSG_ORIG(MSG_STR_EMPTY);
else if (sdp->sd_flags & FLG_SY_SMGOT)
refstr = MSG_ORIG(MSG_GOT_SMALL_PIC);
else
refstr = MSG_ORIG(MSG_GOT_BIG_PIC);
if (sdp == 0)
name = MSG_ORIG(MSG_STR_EMPTY);
else if (sdp->sd_name)
name = Dbg_demangle_name(sdp->sd_name);
else
name = MSG_INTL(MSG_STR_UNKNOWN);
if (stage == 0)
gotaddval = gnp->gn_addend;
else
gotaddval = *gptr;
if ((sdp == 0) || (sdp->sd_sym->st_shndx == SHN_UNDEF) ||
(sdp->sd_file == 0)) {
dbg_print(lml, MSG_INTL(MSG_GOT_FORMAT1), index,
refstr, EC_OFF(off), EC_XWORD(gotaddval), name);
} else {
dbg_print(lml, MSG_INTL(MSG_GOT_FORMAT2), index,
refstr, EC_OFF(off), EC_XWORD(gotaddval),
sdp->sd_file->ifl_name, name);
}
}
}
void
Dbg_sec_order_list(Ofl_desc *ofl, int flag)
{
Os_desc *osp;
Is_desc *isp1;
Aliste idx1;
Lm_list *lml = ofl->ofl_lml;
const char *str;
if (DBG_NOTCLASS(DBG_C_SECTIONS))
return;
if (DBG_NOTDETAIL())
return;
Dbg_util_nl(lml, DBG_NL_STD);
/*
* If the flag == 0, then the routine is called before sorting.
*/
if (flag == 0)
str = MSG_INTL(MSG_ORD_SORT_BEFORE);
else
str = MSG_INTL(MSG_ORD_SORT_AFTER);
for (APLIST_TRAVERSE(ofl->ofl_ordered, idx1, osp)) {
int os_isdescs_idx;
Aliste idx2;
Dbg_util_nl(lml, DBG_NL_STD);
dbg_print(lml, str, osp->os_name);
dbg_print(lml, MSG_INTL(MSG_ORD_HDR_1),
EC_WORD(aplist_nitems(osp->os_isdescs[OS_ISD_BEFORE])),
EC_WORD(aplist_nitems(osp->os_isdescs[OS_ISD_ORDERED])),
EC_WORD(aplist_nitems(osp->os_isdescs[OS_ISD_DEFAULT])),
EC_WORD(aplist_nitems(osp->os_isdescs[OS_ISD_AFTER])));
OS_ISDESCS_TRAVERSE(os_isdescs_idx, osp, idx2, isp1) {
dbg_isec_name_buf_t buf;
char *alloc_mem;
const char *isp1_str;
Word link;
Ifl_desc *ifl = isp1->is_file;
Is_desc *isp2;
const char *msg;
/*
* An output segment that requires ordering might have
* as little as two sorted input sections. For example,
* the crt's can provide a SHN_BEGIN and SHN_AFTER, and
* only these two sections must be processed. Thus, if
* a input section is unordered, move on. Diagnosing
* any unsorted section can produce way too much noise.
*/
if ((isp1->is_flags & FLG_IS_ORDERED) == 0)
continue;
if (isp1->is_shdr->sh_flags & SHF_ORDERED) {
link = isp1->is_shdr->sh_info;
msg = MSG_ORIG(MSG_SH_INFO);
} else { /* SHF_LINK_ORDER */
link = isp1->is_shdr->sh_link;
msg = MSG_ORIG(MSG_SH_LINK);
}
isp1_str = dbg_fmt_isec_name(isp1, buf, &alloc_mem);
if (link == SHN_BEFORE) {
dbg_print(lml, MSG_INTL(MSG_ORD_TITLE_1), msg,
isp1_str, isp1->is_file->ifl_name);
} else if (link == SHN_AFTER) {
dbg_print(lml, MSG_INTL(MSG_ORD_TITLE_2), msg,
isp1_str, isp1->is_file->ifl_name);
} else {
isp2 = ifl->ifl_isdesc[link];
dbg_print(lml, MSG_INTL(MSG_ORD_TITLE_3),
EC_WORD(isp2->is_keyident), isp1_str,
ifl->ifl_name, msg, isp2->is_name);
}
if (alloc_mem != NULL)
free(alloc_mem);
}
}
void
Dbg_sec_order_list(Ofl_desc *ofl, int flag)
{
Os_desc *osp;
Is_desc *isp1;
Listnode *lnp1, *lnp2;
Lm_list *lml = ofl->ofl_lml;
const char *str;
if (DBG_NOTCLASS(DBG_C_SECTIONS))
return;
if (DBG_NOTDETAIL())
return;
Dbg_util_nl(lml, DBG_NL_STD);
/*
* If the flag == 0, then the routine is called before sorting.
*/
if (flag == 0)
str = MSG_INTL(MSG_ORD_SORT_BEFORE);
else
str = MSG_INTL(MSG_ORD_SORT_AFTER);
for (LIST_TRAVERSE(&ofl->ofl_ordered, lnp1, osp)) {
Sort_desc *sort = osp->os_sort;
dbg_print(lml, str, osp->os_name);
dbg_print(lml, MSG_INTL(MSG_ORD_HDR_1),
EC_WORD(sort->st_beforecnt), EC_WORD(sort->st_aftercnt),
EC_WORD(sort->st_ordercnt));
for (LIST_TRAVERSE(&osp->os_isdescs, lnp2, isp1)) {
Word link;
Ifl_desc *ifl = isp1->is_file;
Is_desc *isp2;
const char *msg;
if ((isp1->is_flags & FLG_IS_ORDERED) == 0) {
dbg_print(lml, MSG_INTL(MSG_ORD_TITLE_0),
isp1->is_name, isp1->is_file->ifl_name);
continue;
}
if (isp1->is_shdr->sh_flags & SHF_ORDERED) {
link = isp1->is_shdr->sh_info;
msg = MSG_ORIG(MSG_SH_INFO);
} else {
/* SHF_LINK_ORDER */
link = isp1->is_shdr->sh_link;
msg = MSG_ORIG(MSG_SH_LINK);
}
if (link == SHN_BEFORE) {
dbg_print(lml, MSG_INTL(MSG_ORD_TITLE_1),
isp1->is_name, isp1->is_file->ifl_name,
msg);
continue;
}
if (link == SHN_AFTER) {
dbg_print(lml, MSG_INTL(MSG_ORD_TITLE_2),
isp1->is_name, isp1->is_file->ifl_name,
msg);
continue;
}
isp2 = ifl->ifl_isdesc[link];
dbg_print(lml, MSG_INTL(MSG_ORD_TITLE_3),
isp1->is_name, ifl->ifl_name, msg, isp2->is_name,
isp2->is_key);
}
}
Dbg_util_nl(lml, DBG_NL_STD);
}