static void
Dbg_tls_modent(Lm_list *lml, TLS_modinfo * tmodent)
{
/*
* MSG_ORIG(MSG_TLS_FLAG_STATIC)
*/
static char flagstr[FLAGSZ];
static Val_desc vda[] = {
{ TM_FLG_STATICTLS, MSG_TLS_FLAG_STATIC },
{ 0, 0 }
};
static CONV_EXPN_FIELD_ARG conv_arg = { flagstr, sizeof (flagstr) };
ulong_t flags;
if ((flags = tmodent->tm_flags) != 0) {
conv_arg.oflags = conv_arg.rflags = flags;
(void) conv_expn_field(&conv_arg, vda, 0);
} else {
flagstr[0] = '\0';
}
dbg_print(lml, MSG_INTL(MSG_TLS_MODENT1),
EC_XWORD((uintptr_t)tmodent->tm_tlsblock),
EC_XWORD(tmodent->tm_stattlsoffset), EC_XWORD(tmodent->tm_flags),
flagstr);
dbg_print(lml, MSG_INTL(MSG_TLS_MODENT2),
EC_XWORD(tmodent->tm_filesz), EC_XWORD(tmodent->tm_memsz),
EC_XWORD(tmodent->tm_modid));
}
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_sec_unsup_strmerge(Lm_list *lml, Is_desc *isp)
{
dbg_isec_name_buf_t buf;
char *alloc_mem;
const char *str;
if (DBG_NOTCLASS(DBG_C_SECTIONS))
return;
/*
* We can only merge string table sections with single byte
* (char) characters. For any other (wide) character types,
* issue a message so the user will understand why these
* sections are not being picked up.
*/
if ((isp->is_shdr->sh_entsize > 1) ||
(isp->is_shdr->sh_addralign > 1)) {
str = (isp->is_file != NULL) ? isp->is_file->ifl_name :
MSG_INTL(MSG_STR_NULL);
dbg_print(lml, MSG_INTL(MSG_SEC_STRMERGE_UNSUP),
dbg_fmt_isec_name(isp, buf, &alloc_mem), str,
EC_XWORD(isp->is_shdr->sh_addralign),
EC_XWORD(isp->is_shdr->sh_entsize));
if (alloc_mem != NULL)
free(alloc_mem);
}
}
void
Dbg_sec_group(Lm_list *lml, Is_desc *isp, Group_desc *gdp)
{
dbg_isec_name_buf_t buf;
char *alloc_mem;
const char *comdat, *isp_str;
if (DBG_NOTCLASS(DBG_C_SECTIONS))
return;
if (gdp->gd_data[0] & GRP_COMDAT)
comdat = MSG_ORIG(MSG_STR_COMDAT);
else
comdat = MSG_ORIG(MSG_STR_EMPTY);
isp_str = dbg_fmt_isec_name(isp, buf, &alloc_mem);
if (isp->is_shdr->sh_type == SHT_GROUP) {
dbg_print(lml, MSG_INTL(MSG_SEC_GRP_DEFINE), isp_str,
isp->is_file->ifl_name, comdat, gdp->gd_name);
} else {
dbg_print(lml, MSG_INTL(MSG_SEC_GRP_MEMBER), isp_str,
isp->is_file->ifl_name, comdat, gdp->gd_name);
}
if (gdp->gd_oisc) {
dbg_print(lml, MSG_INTL(MSG_SEC_GRP_DISCARDED), isp_str,
isp->is_file->ifl_name, gdp->gd_name,
gdp->gd_oisc->is_file->ifl_name);
}
if (alloc_mem != NULL)
free(alloc_mem);
}
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_sec_in(Lm_list *lml, Is_desc *isp)
{
if (DBG_NOTCLASS(DBG_C_SECTIONS))
return;
if (isp->is_flags & FLG_IS_GNSTRMRG) {
/*
* This section was generated because we have 1 or
* more SHF_MERGE|SHF_STRINGS input sections that we
* wish to merge. This new section will ultimately
* end up replacing those sections once it has been filled
* with their strings (merged and compressed) and relocations
* have been redirected.
*/
dbg_print(lml, MSG_INTL(MSG_SEC_INPUT_GENSTR), isp->is_name);
} else if (isp->is_file == NULL) {
/* Generated input section */
dbg_print(lml, MSG_INTL(MSG_SEC_INPUT_GEN), isp->is_name);
} else {
/* Standard input section */
dbg_isec_name_buf_t buf;
char *alloc_mem;
dbg_print(lml, MSG_INTL(MSG_SEC_INPUT),
dbg_fmt_isec_name(isp, buf, &alloc_mem),
isp->is_file->ifl_name);
if (alloc_mem != NULL)
free(alloc_mem);
}
}
/*
* Common processing for capabilities value setting.
*
* entry:
* argstate - Argument state block
* cap - capabilities data pointer
* ndx - capabilities data index
* cap_ndx - capabilities section index
* cap_name - capabilities section name
* cap_tag - capabilities tag
* const_type - data conversion type
*/
static elfedit_cmdret_t
cap_set(ARGSTATE *argstate, Cap *cap, Word ndx, Word cap_ndx,
const char *cap_name, Xword cap_tag, elfedit_const_t const_type)
{
Conv_cap_val_buf_t buf1, buf2;
Half mach = argstate->obj_state->os_ehdr->e_machine;
Xword ncap, ocap;
ncap = flag_bitop(argstate, cap[ndx].c_un.c_val,
elfedit_const_to_atoui(const_type));
/* Set the value */
if ((ocap = cap[ndx].c_un.c_val) == ncap) {
elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_BSB_OK),
cap_ndx, cap_name, EC_WORD(ndx),
conv_cap_val(cap_tag, ocap, mach, CONV_FMT_NOBKT, &buf1));
return (ELFEDIT_CMDRET_NONE);
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_BSB_CHG),
cap_ndx, cap_name, EC_WORD(ndx),
conv_cap_val(cap_tag, ocap, mach, CONV_FMT_NOBKT, &buf1),
conv_cap_val(cap_tag, ncap, mach, CONV_FMT_NOBKT, &buf2));
cap[ndx].c_un.c_val = ncap;
return (ELFEDIT_CMDRET_MOD);
}
}
/*
* Called after getopt() processing is finished if there is a non-empty
* match list. Prepares the matching code for use.
*
* exit:
* Returns True (1) if no errors are encountered. Writes an
* error string to stderr and returns False (0) otherwise.
*/
static int
match_prepare(char *argv0, uint_t flags)
{
match_rec_t *list;
const char *str;
int minus_p = (flags & FLG_SHOW_PHDR) != 0;
atoui_type_t atoui_type;
/*
* Flag ambiguous attempt to use match option with both -p and
* and one or more section SHOW options. In this case, we
* can't tell what type of item we're supposed to match against.
*/
if (minus_p && (flags & FLG_MASK_SHOW_SHDR)) {
(void) fprintf(stderr, MSG_INTL(MSG_ERR_AMBIG_MATCH),
basename(argv0));
return (0);
}
/* Set the match type, based on the presence of the -p option */
if (minus_p) {
match_state.item_type = MATCH_ITEM_PT;
atoui_type = ATOUI_PT;
} else {
match_state.item_type = MATCH_ITEM_SHT;
atoui_type = ATOUI_SHT;
}
/*
* Scan match list and perform any necessary fixups:
*
* MATCH_OPT_NAME: If -p is specified, convert MATCH_OPT_NAME (-N)
* requests into MATCH_OPT_TYPE (-T).
*
* MATCH_OPT_TYPE: Now that we know item type we are matching
* against, we can convert the string saved in the name
* field during getopt() processing into an integer and
* write it into the type field.
*/
for (list = match_state.list; list; list = list->next) {
if ((list->opt_type == MATCH_OPT_NAME) && minus_p)
list->opt_type = MATCH_OPT_TYPE;
if (list->opt_type != MATCH_OPT_TYPE)
continue;
str = list->value.name;
if (atoui(str, atoui_type, &list->value.type) == 0) {
const char *fmt = minus_p ?
MSG_INTL(MSG_ERR_BAD_T_PT) :
MSG_INTL(MSG_ERR_BAD_T_SHT);
(void) fprintf(stderr, fmt, basename(argv0), str);
return (0);
}
}
return (1);
}
void
Dbg_sec_created(Lm_list *lml, Os_desc *osp, Sg_desc *sgp)
{
if (DBG_NOTCLASS(DBG_C_SECTIONS))
return;
dbg_print(lml, MSG_INTL(MSG_SEC_CREATED), osp->os_name,
(sgp->sg_name ? sgp->sg_name : MSG_INTL(MSG_STR_NULL)));
}
/*
* Create an archive descriptor. By maintaining a list of archives any
* duplicate occurrences of the same archive specified by the user enable us to
* pick off where the last processing finished.
*/
Ar_desc *
ld_ar_setup(const char *name, Elf *elf, Ofl_desc *ofl)
{
Ar_desc * adp;
size_t number;
Elf_Arsym * start;
/*
* Unless, -z allextract is specified, get the archive symbol table
* if one exists, and ignore the file with a warning message otherwise.
*/
if (ofl->ofl_flags1 & FLG_OF1_ALLEXRT) {
start = NULL;
} else if ((start = elf_getarsym(elf, &number)) == NULL) {
if (elf_errno())
ld_eprintf(ofl, ERR_ELF, MSG_INTL(MSG_ELF_GETARSYM),
name);
else
ld_eprintf(ofl, ERR_WARNING, MSG_INTL(MSG_ELF_ARSYM),
name);
return (0);
}
/*
* As this is a new archive reference establish a new descriptor.
*/
if ((adp = libld_malloc(sizeof (Ar_desc))) == NULL)
return ((Ar_desc *)S_ERROR);
adp->ad_name = name;
adp->ad_elf = elf;
adp->ad_start = start;
if (start) {
adp->ad_aux = libld_calloc(sizeof (Ar_aux), number);
if (adp->ad_aux == NULL)
return ((Ar_desc *)S_ERROR);
} else {
adp->ad_aux = NULL;
}
/*
* Retain any command line options that are applicable to archive
* extraction in case we have to rescan this archive later.
*/
adp->ad_flags = ofl->ofl_flags1 & MSK_OF1_ARCHIVE;
ofl->ofl_arscnt++;
/*
* Add this new descriptor to the list of archives.
*/
if (aplist_append(&ofl->ofl_ars, adp, AL_CNT_OFL_LIBS) == NULL)
return ((Ar_desc *)S_ERROR);
else
return (adp);
}
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_unused_file(Lm_list *lml, const char *name, int needstr, uint_t cycle)
{
if (DBG_NOTCLASS(DBG_C_UNUSED))
return;
if (needstr)
dbg_print(lml, MSG_INTL(MSG_USD_NEEDSTR), name);
else if (cycle)
dbg_print(lml, MSG_INTL(MSG_USD_FILECYCLIC), name, cycle);
else
dbg_print(lml, MSG_INTL(MSG_USD_FILE), name);
}
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));
}
/*
* "delete" items in an array by copying the following items up
* over the "deleted" items and then zero filling the vacated
* slots at the bottom.
*
* entry:
* name_str - Array identification prefix to use for debug message
* data_start - Address of 1st byte in array
* entsize - sizeof a single element of the array
* num_ent - # of elements in array
* start_ndx - Index of first item to be deleted
* cnt - # of items to delete
*
* exit:
* Any errors are issued and control does not return to the
* caller. On success, the items have been removed, zero filling
* has been done, and debug messages issued.
*/
void
elfedit_array_elts_delete(const char *name_str, void *data_start,
size_t entsize, size_t num_ent, size_t start_ndx, size_t cnt)
{
char *data = data_start;
/* The specified index and range must be in bounds */
if ((start_ndx + cnt) > num_ent)
elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_ARRBNDS),
name_str, EC_WORD(num_ent), EC_WORD(num_ent - 1));
/*
* Everything below the deleted items moves up.
* Note that bcopy() is documented to handle overlapping
* src/dst correctly, so we make no effort to handle this
* element by element, but issue a single operation.
*
* If we're doing the last element, there is nothing to
* move up, and we skip this step, moving on to the zeroing below.
*/
if (start_ndx < (num_ent - 1)) {
size_t ncpy = num_ent - (start_ndx + cnt);
bcopy(data + ((start_ndx + cnt) * entsize),
data + (start_ndx * entsize), ncpy * entsize);
if (ncpy == 1) {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_ARRCPY_1), name_str,
EC_WORD(start_ndx + cnt), EC_WORD(start_ndx));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG,
MSG_INTL(MSG_DEBUG_ARRCPY_N), name_str,
EC_WORD(start_ndx + cnt),
EC_WORD(start_ndx + cnt + ncpy - 1),
EC_WORD(start_ndx),
EC_WORD(start_ndx + ncpy - 1));
}
}
/* Zero out the vacated elements at the end */
bzero(data + ((num_ent - cnt) * entsize), entsize * cnt);
if (cnt == 1) {
elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_ARRZERO_1),
name_str, EC_WORD(num_ent - 1));
} else {
elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_ARRZERO_N),
name_str, EC_WORD(num_ent - cnt),
EC_WORD(num_ent - 1), EC_WORD(cnt));
}
}
void
Dbg_audit_objfilter(Lm_list *lml, int call, const char *lib,
const char *filter, const char *filtee, const char *ref)
{
if (DBG_NOTCLASS(DBG_C_AUDITING))
return;
if (call == DBG_AUD_CALL) {
Dbg_util_nl(lml, DBG_NL_STD);
dbg_print(lml, MSG_INTL(MSG_AUD_OBJFILTER), lib, filter,
filtee, ref);
} else
dbg_print(lml, MSG_INTL(MSG_AUD_OBJFILTER_R), lib, filter);
}
/*
* Process the given archive and extract objects for inclusion into
* the link.
*
* entry:
* name - Name of archive
* fd - Open file descriptor for archive
* adp - Archive descriptor
* ofl - output descriptor
*
* exit:
* Returns FALSE on fatal error, TRUE otherwise.
*/
Boolean
ld_process_archive(const char *name, int fd, Ar_desc *adp, Ofl_desc *ofl)
{
Boolean found = FALSE;
Rej_desc rej = { 0 };
/*
* If a fatal error condition has been set there's really no point in
* processing the archive further. Having got to this point we have at
* least established that the archive exists (thus verifying that the
* command line options that got us to this archive are correct). Very
* large archives can take a significant time to process, therefore
* continuing on from here may significantly delay the fatal error
* message the user is already set to receive.
*/
if (ofl->ofl_flags & FLG_OF_FATAL)
return (TRUE);
/*
* If this archive was processed with -z allextract, then all members
* have already been extracted.
*/
if (adp->ad_elf == NULL)
return (TRUE);
if (ofl->ofl_flags1 & FLG_OF1_ALLEXRT) {
if (!ar_extract_all(name, fd, adp, ofl, &found, &rej))
return (FALSE);
} else {
if (!ar_extract_bysym(name, fd, adp, ofl, &found, &rej))
return (FALSE);
}
/*
* If no objects have been found in the archive test for any rejections
* and if one had occurred issue a warning - its possible a user has
* pointed at an archive containing the wrong class of elf members.
*/
if ((found == 0) && rej.rej_type) {
Conv_reject_desc_buf_t rej_buf;
ld_eprintf(ofl, ERR_WARNING, MSG_INTL(reject[rej.rej_type]),
rej.rej_name ? rej.rej_name : MSG_INTL(MSG_STR_UNKNOWN),
conv_reject_desc(&rej, &rej_buf, ld_targ.t_m.m_mach));
}
return (TRUE);
}
void
Dbg_sec_in(Lm_list *lml, Is_desc *isp)
{
const char *str;
if (DBG_NOTCLASS(DBG_C_SECTIONS))
return;
if (isp->is_file != NULL)
str = isp->is_file->ifl_name;
else
str = MSG_INTL(MSG_STR_NULL);
dbg_print(lml, MSG_INTL(MSG_SEC_INPUT), isp->is_name, str);
}
void
Dbg_sec_created(Lm_list *lml, Os_desc *osp, Sg_desc *sgp)
{
const char *str;
if (DBG_NOTCLASS(DBG_C_SECTIONS))
return;
if (sgp->sg_name && *sgp->sg_name)
str = sgp->sg_name;
else
str = MSG_INTL(MSG_STR_NULL);
dbg_print(lml, MSG_INTL(MSG_SEC_CREATED), osp->os_name, str);
}
/*
* This function is supplied to elfedit through our elfedit_module_t
* definition. It translates the opaque elfedit_i18nhdl_t handles
* in our module interface into the actual strings for elfedit to
* use.
*
* note:
* This module uses Msg codes for its i18n handle type.
* So the translation is simply to use MSG_INTL() to turn
* it into a string and return it.
*/
static const char *
mod_i18nhdl_to_str(elfedit_i18nhdl_t hdl)
{
Msg msg = (Msg)hdl;
return (MSG_INTL(msg));
}
static int
remap_profile(int fd)
{
caddr_t addr;
size_t l_fsize;
l_fsize = Hptr->hd_fsize;
if ((addr = (caddr_t)mmap(0, l_fsize, (PROT_READ | PROT_WRITE),
MAP_SHARED, fd, 0)) == (char *)-1) {
int err = errno;
(void) fprintf(stderr, MSG_INTL(MSG_SYS_MMAP), Profile,
strerror(err));
return (0);
}
(void) munmap((caddr_t)Hptr, Fsize);
Fsize = l_fsize;
/* LINTED */
Hptr = (L_hdr*) addr;
/* LINTED */
Cptr = (L_cgarc *)(addr + sizeof (L_hdr) + Hptr->hd_psize);
return (1);
}
/*
* Add an entry to match_state.list for use by match(). This routine is for
* use during getopt() processing. It should not be called once
* match_prepare() has been called.
*
* Return True (1) for success. On failure, an error is written
* to stderr, and False (0) is returned.
*/
static int
add_match_record(char *argv0, match_rec_t *data)
{
match_rec_t *rec;
match_rec_t *list;
if ((rec = malloc(sizeof (*rec))) == NULL) {
int err = errno;
(void) fprintf(stderr, MSG_INTL(MSG_ERR_MALLOC),
basename(argv0), strerror(err));
return (0);
}
*rec = *data;
/* Insert at end of match_state.list */
if (match_state.list == NULL) {
match_state.list = rec;
} else {
for (list = match_state.list; list->next != NULL;
list = list->next)
;
list->next = rec;
}
rec->next = NULL;
return (1);
}
void
Dbg_sec_group(Lm_list *lml, Is_desc *isp, Group_desc *gdp)
{
const char *fmt;
if (DBG_NOTCLASS(DBG_C_SECTIONS))
return;
if (gdp->gd_flags & GRP_FLG_DISCARD)
fmt = MSG_INTL(MSG_SEC_GRP_DISCARDED);
else
fmt = MSG_INTL(MSG_SEC_GRP_INPUT);
dbg_print(lml, fmt, isp->is_name, isp->is_file->ifl_name,
gdp->gd_gsectname, gdp->gd_symname);
}
void
Dbg_audit_pltenter(Lm_list *lml, int call, const char *lib, const char *name,
Addr value)
{
if (DBG_NOTCLASS(DBG_C_AUDITING))
return;
if (call == DBG_AUD_CALL) {
Dbg_util_nl(lml, DBG_NL_STD);
dbg_print(lml, MSG_INTL(MSG_AUD_PLTENTER), lib, name,
EC_XWORD(value));
} else {
dbg_print(lml, MSG_INTL(MSG_AUD_PLTENTER_R), lib, name,
EC_XWORD(value));
}
}
Group_desc *
ld_get_group(Ofl_desc *ofl, Is_desc *isp)
{
Ifl_desc *ifl = isp->is_file;
uint_t scnndx = isp->is_scnndx;
Group_desc *gdp;
Aliste idx;
/*
* Scan the GROUP sections associated with this file to find the
* matching group section.
*/
for (ALIST_TRAVERSE(ifl->ifl_groups, idx, gdp)) {
size_t ndx;
Word *data;
if (isp->is_shdr->sh_type == SHT_GROUP) {
if (isp->is_scnndx == gdp->gd_isc->is_scnndx)
return (gdp);
continue;
}
data = gdp->gd_data;
for (ndx = 1; ndx < gdp->gd_cnt; ndx++) {
if (data[ndx] == scnndx)
return (gdp);
}
}
ld_eprintf(ofl, ERR_FATAL, MSG_INTL(MSG_ELF_NOGROUPSECT),
ifl->ifl_name, EC_WORD(isp->is_scnndx), isp->is_name);
return (NULL);
}
void
Dbg_audit_lib(Rt_map *clmp, const char *lib, int type)
{
Lm_list *clml = LIST(clmp);
const char *str;
if (DBG_NOTCLASS(DBG_C_AUDITING))
return;
Dbg_util_nl(clml, DBG_NL_STD);
switch (type) {
case DBG_AUD_PRELOAD:
str = MSG_ORIG(MSG_AUD_PRELOAD);
break;
case DBG_AUD_GLOBAL:
str = MSG_ORIG(MSG_AUD_GLOBAL);
break;
case DBG_AUD_LOCAL:
/* FALLTHROUGH */
default:
str = MSG_ORIG(MSG_STR_EMPTY);
}
dbg_print(clml, MSG_INTL(MSG_AUD_LIB), lib, NAME(clmp), str);
}
/*
* Exit after cleaning up.
*/
int
ld_exit(Ofl_desc *ofl)
{
/*
* If we have created an output file remove it.
*/
if ((ofl->ofl_fd > 0) && ((ofl->ofl_flags1 & FLG_OF1_NONREG) == 0))
(void) unlink(ofl->ofl_name);
/*
* Inform any support library that the link-edit has failed.
*/
ld_sup_atexit(ofl, 1);
/*
* Wrap up debug output file if one is open
*/
dbg_cleanup();
/* If any ERR_GUIDANCE messages were issued, add a summary */
if (ofl->ofl_guideflags & FLG_OFG_ISSUED)
ld_eprintf(ofl, ERR_GUIDANCE, MSG_INTL(MSG_GUIDE_SUMMARY));
return (1);
}
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_audit_version(Lm_list *lml, const char *lib, uint_t overs, uint_t nvers)
{
if (DBG_NOTCLASS(DBG_C_AUDITING))
return;
dbg_print(lml, MSG_INTL(MSG_AUD_VERSION), lib, overs, nvers);
}
void
Dbg_support_load(Lm_list *lml, const char *obj, const char *func)
{
if (DBG_NOTCLASS(DBG_C_SUPPORT))
return;
dbg_print(lml, MSG_INTL(MSG_SUP_ROUTINE), obj, func);
}
