8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / cmd / sgs / elfedit / common / util_machelf.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include        <stdlib.h>
#include        <stdio.h>
#include        <unistd.h>
#include        <libintl.h>
#include        <_machelf.h>
#include        <libelf.h>
#include        <link.h>
#include        <strings.h>
#include        <ctype.h>
#include        "msg.h"
#include        <elfedit.h>
#include        <conv.h>
#include        <sys/elf_SPARC.h>
#include        <sys/elf_amd64.h>



/*
 * ELFCLASS specific code that would otherwise be found in util.c
 */




/*
 * When you modify ELF constructs, you need to tell libelf that you've
 * done so. Otherwise, the changes may not be flushed back to the
 * output file.
 *
 * The elfedit_modified_*() functions exist to simplify the calls to
 * the underlying elf_flag*() functions.
 */
void
elfedit_modified_ehdr(elfedit_obj_state_t *obj_state)
{
        (void) elf_flagehdr(obj_state->os_elf, ELF_C_SET, ELF_F_DIRTY);
}

void
elfedit_modified_phdr(elfedit_obj_state_t *obj_state)
{
        (void) elf_flagphdr(obj_state->os_elf, ELF_C_SET, ELF_F_DIRTY);
}

void
elfedit_modified_shdr(elfedit_section_t *s)
{
        (void) elf_flagshdr(s->sec_scn, ELF_C_SET, ELF_F_DIRTY);
}

void
elfedit_modified_data(elfedit_section_t *s)
{
        (void) elf_flagdata(s->sec_data, ELF_C_SET, ELF_F_DIRTY);
}



/*
 * Prepare an elfedit_dyn_elt_t structure for use.
 */
void
elfedit_dyn_elt_init(elfedit_dyn_elt_t *elt)
{
        elt->dn_seen = 0;
}

/*
 * Given a dynamic section item, save it in the given elfedit_dyn_elt_t
 * structure and mark that structure to show that it is present.
 */
void
elfedit_dyn_elt_save(elfedit_dyn_elt_t *elt, Word ndx, Dyn *dyn)
{
        elt->dn_seen = 1;
        elt->dn_ndx = ndx;
        elt->dn_dyn = *dyn;
}


/*
 * Return the index of the first section that has the given name.
 *
 * entry:
 *      obj_state - Object state.
 *      shnam - Name of desired section
 *
 * exit:
 *      On success, returns the section index. On failure, an error
 *      is issued, and this routine does not return to the caller.
 */
Word
elfedit_name_to_shndx(elfedit_obj_state_t *obj_state, const char *shnam)
{
        elfedit_section_t *sec = obj_state->os_secarr;
        Word    ndx;
        Word    shnum = obj_state->os_shnum;

        for (ndx = 0; ndx < shnum; ndx++, sec++) {
                if (strcmp(shnam, sec->sec_name) == 0) {
                        elfedit_msg(ELFEDIT_MSG_DEBUG,
                            MSG_INTL(MSG_DEBUG_SHNAM2NDX),
                            EC_WORD(sec->sec_shndx), sec->sec_name, shnam);
                        return (ndx);
                }
        }

        /* If didn't return in loop above, the name doesn't match */
        elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOSECNAM), shnam);
        /*NOTREACHED*/
        return (SHN_UNDEF);
}



/*
 * Return the index of the first section that has the given type.
 *
 * entry:
 *      obj_state - Object state.
 *      shtype - Type of desired section
 *
 * exit:
 *      On success, returns the section index. On failure, an error
 *      is issued, and this routine does not return to the caller.
 */
Word
elfedit_type_to_shndx(elfedit_obj_state_t *obj_state, Word shtype)
{
        Conv_inv_buf_t inv_buf;
        elfedit_section_t *sec = obj_state->os_secarr;
        Word    ndx;
        Word    shnum = obj_state->os_shnum;

        for (ndx = 0; ndx < shnum; ndx++, sec++) {
                if (shtype == sec->sec_shdr->sh_type) {
                        elfedit_msg(ELFEDIT_MSG_DEBUG,
                            MSG_INTL(MSG_DEBUG_SHNAM2NDX),
                            EC_WORD(sec->sec_shndx), sec->sec_name,
                            conv_sec_type(
                            obj_state->os_ehdr->e_ident[EI_OSABI],
                            obj_state->os_ehdr->e_machine,
                            shtype, 0, &inv_buf));
                        return (ndx);
                }
        }

        /* If didn't return in loop above, the name doesn't match */
        elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOSECTYP),
            conv_sec_type(obj_state->os_ehdr->e_ident[EI_OSABI],
            obj_state->os_ehdr->e_machine, shtype, 0, &inv_buf));
        /*NOTREACHED*/
        return (SHN_UNDEF);
}



/*
 * Locate the index of the first symbol that has the given name
 *
 * entry:
 *      obj_state - Object state.
 *      symsec - Symbol section
 *      strsec = String section
 *      name - String giving name of symbol to lookup
 *      msg_type - ELFEDIT_MSG_ type code to use with message
 *              issued if name does not exist in symbol table.
 *      ret_symndx - Address of variable to receive index.
 *
 * exit:
 *      On success, issues debug message, sets *ret_symndx, and returns
 *      True (1).
 *
 *      On failure, issues a message using msg_type to determine
 *      the type of message sent. If the message does not take control away
 *      from the caller, False (0) is returned.
 *
 * note:
 *      Although the string table is referenced by the sh_link field of
 *      the symbol table, we require the user to supply it rather than
 *      look it up. The reason for this is that the caller will usually
 *      have looked it up, and we wish to avoid multiple debug messages
 *      from being issued to that effect.
 */
int
elfedit_name_to_symndx(elfedit_section_t *symsec, elfedit_section_t *strsec,
    const char *name, elfedit_msg_t msg_type, Word *ret_symndx)

{
        Sym     *sym = (Sym *) symsec->sec_data->d_buf;
        Word    cnt = symsec->sec_shdr->sh_size / symsec->sec_shdr->sh_entsize;
        Word    ndx, offset;
        const char      *curname;

        for (ndx = 0; ndx < cnt; ndx++) {
                offset = sym[ndx].st_name;

                curname = elfedit_offset_to_str(strsec, offset,
                    ELFEDIT_MSG_ERR, 0);
                if (strcmp(curname, name) == 0) {
                        elfedit_msg(ELFEDIT_MSG_DEBUG,
                            MSG_INTL(MSG_DEBUG_SYMNAM2NDX),
                            EC_WORD(symsec->sec_shndx),
                            symsec->sec_name, EC_WORD(ndx), name);
                        *ret_symndx = ndx;
                        return (1);
                }
        }

        /* If didn't return in loop above, the name doesn't match */
        elfedit_msg(msg_type, MSG_INTL(MSG_ERR_NOSYM),
            EC_WORD(symsec->sec_shndx), symsec->sec_name, name);
        /*NOTREACHED*/
        return (0);             /* lint */
}


/*
 * Given a section index, turn it into a descriptive string.
 *      - If it is one of the special reserved indexes, the
 *              symbolic name is returned.
 *      - If it is a regular section, in range for the file,
 *              the name associated with the section is returned.
 *      - Otherwise, the number is formatted as numeric ASCII.
 *
 * exit:
 *      A pointer to the static buffer containing the name is
 *      returned. This pointer is valid until the next call
 *      to elfedit_shndx_to_name(), and which point it may
 *      be overwritten.
 */
const char *
elfedit_shndx_to_name(elfedit_obj_state_t *obj_state, Word shndx)
{
        /*
         * This routine can be called twice within a single C statement,
         * so we use alternating buffers on each call to allow this
         * without requiring the caller to supply a buffer (the size of
         * which they don't know).
         */
        static Conv_inv_buf_t   buf1, buf2;
        static Conv_inv_buf_t   *buf;

        /*
         * If it is outside of the reserved area, and inside the
         * range of section indexes in the ELF file, then show
         * the section name.
         */
        if ((shndx < obj_state->os_shnum) &&
            ((shndx < SHN_LORESERVE) || (shndx > SHN_HIRESERVE)) &&
            (shndx != SHN_UNDEF))
                return (obj_state->os_secarr[shndx].sec_name);

        /*
         * Anything else is handled by libconv. It will return standard
         * names for known items, or format as a number otherwise.
         */
        buf = (buf == &buf1) ? &buf2 : &buf1;   /* Switch buffers */
        return (conv_sym_shndx(obj_state->os_ehdr->e_ident[EI_OSABI],
            obj_state->os_ehdr->e_machine, shndx,
            CONV_FMT_ALT_CF | CONV_FMT_DECIMAL, buf));
}


/*
 * Locate the arbitrary section specified by shndx for this object.
 *
 * exit:
 *      Returns section descriptor on success. On failure, does not return.
 */
elfedit_section_t *
elfedit_sec_get(elfedit_obj_state_t *obj_state, Word shndx)
{
        elfedit_section_t *sec;

        if ((shndx == 0) || (shndx >= obj_state->os_shnum))
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_BADSECNDX),
                    EC_WORD(shndx), EC_WORD(obj_state->os_shnum - 1));

        sec = &obj_state->os_secarr[shndx];

        elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_FNDSEC),
            EC_WORD(shndx), sec->sec_name);
        return (sec);
}



/*
 * Compare the a specified osabi with that of the current object.
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      issue_err - True if this routine should issue an error and
 *              not return to the caller if osabi is not native.
 *
 * exit:
 *      If current osabi is the one specified, True (1) is returned.
 *
 *      Otherwise, if issue_err is True, an error is issued and this
 *      routine does not return to the caller. If issue_err is False,
 *      False (0) is returned.
 *
 * note:
 *      ELFOSABI_NONE is considered to be equivalent to ELFOSABI_SOLARIS.
 */
int
elfedit_test_osabi(elfedit_obj_state_t *obj_state, uchar_t osabi,
    int issue_err)
{
        uchar_t         obj_osabi = obj_state->os_ehdr->e_ident[EI_OSABI];
        Conv_inv_buf_t  inv_buf;

        if (obj_osabi == ELFOSABI_NONE)
                obj_osabi = ELFOSABI_SOLARIS;

        if (osabi == obj_osabi)
                return (1);

        if (issue_err)
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_BADOSABI),
                    conv_ehdr_osabi(osabi, 0, &inv_buf));
        return (0);
}

/*
 * Locate the capabilities section for this object
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      cap - Address of variable to recieve pointer to capabilities
 *              section data buffer.
 *      num - Address of variable to receive number of items
 *              referenced by cap.
 *
 * exit:
 *      On success, returns section descriptor, and sets the
 *      variables referenced by cap and num.  On failure,
 *      does not return.
 */
elfedit_section_t *
elfedit_sec_getcap(elfedit_obj_state_t *obj_state, Cap **cap, Word *num)
{
        Word cnt;
        elfedit_section_t *cache;

        (void) elfedit_test_osabi(obj_state, ELFOSABI_SOLARIS, 1);

        for (cnt = 1; cnt < obj_state->os_shnum; cnt++) {
                cache = &obj_state->os_secarr[cnt];
                if (cache->sec_shdr->sh_type == SHT_SUNW_cap) {
                        elfedit_msg(ELFEDIT_MSG_DEBUG,
                            MSG_INTL(MSG_DEBUG_FNDCAP),
                            EC_WORD(cnt), cache->sec_name);
                        *cap = (Cap *) cache->sec_data->d_buf;
                        *num = cache->sec_shdr->sh_size /
                            cache->sec_shdr->sh_entsize;
                        return (cache);
                }
        }

        /* If here, this object has no capabilities section */
        elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOCAP));

        /*NOTREACHED*/
        return (NULL);
}


/*
 * Locate the dynamic section for this object
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      dyn - Address of variable to recieve pointer to dynamic
 *              section data buffer.
 *      numdyn - Address of variable to receive number of items
 *              referenced by dyn.
 *
 * exit:
 *      On success, returns section descriptor, and sets the
 *      variables referenced by dyn and numdyn.  On failure,
 *      does not return.
 */
elfedit_section_t *
elfedit_sec_getdyn(elfedit_obj_state_t *obj_state, Dyn **dyn, Word *num)
{
        elfedit_section_t *cache;

        if (obj_state->os_dynndx != SHN_UNDEF) {
                cache = &obj_state->os_secarr[obj_state->os_dynndx];
                elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_FNDDYN),
                    EC_WORD(cache->sec_shndx), cache->sec_name);
                *dyn = (Dyn *) cache->sec_data->d_buf;
                *num = cache->sec_shdr->sh_size / cache->sec_shdr->sh_entsize;
                return (cache);
        }

        /* If here, this object has no dynamic section */
        elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NODYN));

        /*NOTREACHED*/
        return (NULL);
}


/*
 * Locate the syminfo section for this object
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      syminfo - Address of variable to recieve pointer to syminfo
 *              section data buffer.
 *      num - Address of variable to receive number of items
 *              referenced by syminfo.
 *
 * exit:
 *      On success, returns section descriptor, and sets the
 *      variables referenced by syminfo and num.  On failure,
 *      does not return.
 */
elfedit_section_t *
elfedit_sec_getsyminfo(elfedit_obj_state_t *obj_state, Syminfo **syminfo,
    Word *num)
{
        Word cnt;
        elfedit_section_t *cache;

        for (cnt = 1; cnt < obj_state->os_shnum; cnt++) {
                cache = &obj_state->os_secarr[cnt];
                if (cache->sec_shdr->sh_type == SHT_SUNW_syminfo) {
                        elfedit_msg(ELFEDIT_MSG_DEBUG,
                            MSG_INTL(MSG_DEBUG_FNDSYMINFO),
                            EC_WORD(cnt), cache->sec_name);
                        *syminfo = (Syminfo *) cache->sec_data->d_buf;
                        *num = cache->sec_shdr->sh_size /
                            cache->sec_shdr->sh_entsize;
                        return (cache);
                }
        }

        /* If here, this object has no syminfo section */
        elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOSYMINFO));

        /*NOTREACHED*/
        return (NULL);
}


/*
 * Check the given section to see if it is a known symbol table type.
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      sec - Section to check
 *      issue_err - True if this routine should issue an error and
 *              not return to the caller if sec is not a symbol table.
 *      atoui_list - NULL, or address of variable to receive a pointer to
 *              an array of elfedit_atoui_sym_t items describing the
 *              type of symbol table found. This array is useful for
 *              doing command completion.
 *
 * exit:
 *      If sec is a symbol table:
 *              - If atoui_list is non-NULL, *atoui_list is set to the
 *                appropriate ELFEDIT_CONST_xx list of items.
 *              - True (1) is returned
 *      If sec is not a symbol table and issue_err is True:
 *              - An error is issued, and this routine does not
 *                      return to the caller.
 *      Otherwise:
 *              - If atoui_list is non-NULL, *atoui_list is set to NULL.
 *              - False (0) is returned
 */
int
elfedit_sec_issymtab(elfedit_obj_state_t *obj_state, elfedit_section_t *sec,
    int issue_err, elfedit_atoui_sym_t **atoui_list)
{
        elfedit_const_t         const_type;
        int                     ret = 1;

        /* Is the section a symbol table? */
        switch (sec->sec_shdr->sh_type) {
        case SHT_SYMTAB:
                const_type = ELFEDIT_CONST_SHT_SYMTAB;
                break;
        case SHT_DYNSYM:
                const_type = ELFEDIT_CONST_SHT_DYNSYM;
                break;
        case SHT_SUNW_LDYNSYM:
                /*
                 * These sections are only known to be symbol tables
                 * if the osabi is Solaris.
                 */
                if (elfedit_test_osabi(obj_state, ELFOSABI_SOLARIS, 0)) {
                        const_type = ELFEDIT_CONST_SHT_LDYNSYM;
                        break;
                }
                /*FALLTHROUGH*/
        default:
                if (issue_err)
                        elfedit_msg(ELFEDIT_MSG_ERR,
                            MSG_INTL(MSG_ERR_NOTSYMTAB),
                            EC_WORD(sec->sec_shndx), sec->sec_name);
                ret = 0;
                break;
        }

        if (atoui_list != NULL)
                *atoui_list = (ret == 0) ? NULL :
                    elfedit_const_to_atoui(const_type);

        return (ret);
}



/*
 * Locate a symbol table section for this object
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      by_index - If True, we want to locate the section with the
 *              section index given by index. If False, we return
 *              the section with the name given by name.
 *      index, name - Key to search for. See by_index.
 *      sym - Address of variable to recieve pointer to symbol
 *              section data buffer.
 *      numsym - Address of variable to receive number of symbols
 *              referenced by sym.
 *      aux_info - Address of variable to receive pointer to the
 *              elfedit_symtab_t struct that ties the symbol table and
 *              its related auxiliary sections together. NULL if this
 *              information is not required.
 *
 * exit:
 *      On success, returns section descriptor, and sets the
 *      variables referenced by sym, and numsym. On failure,
 *      does not return.
 */
elfedit_section_t *
elfedit_sec_getsymtab(elfedit_obj_state_t *obj_state, int by_index,
    Word index, const char *name, Sym **sym, Word *num,
    elfedit_symtab_t **aux_info)
{
        Word                    ndx;
        elfedit_section_t       *symsec = NULL;
        elfedit_symtab_t        *symtab;
        const char              *type_name;

        /* If looking it up by index, make sure the index is in range */
        if (by_index && (index >= obj_state->os_shnum))
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_BADSECNDX),
                    EC_WORD(index), EC_WORD(obj_state->os_shnum - 1));

        /*
         * Look at each known symbol table in turn until the desired
         * one is hit, or there are no more.
         */
        symtab = obj_state->os_symtab;
        for (ndx = 0; ndx < obj_state->os_symtabnum; ndx++, symtab++) {
                elfedit_section_t *s =
                    &obj_state->os_secarr[symtab->symt_shndx];

                if ((by_index && (symtab->symt_shndx == index)) ||
                    (!by_index && (strcmp(s->sec_name, name) == 0))) {
                                symsec = s;
                                break;
                }
        }

        /* Did we get a section? */
        if (symsec == NULL)
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOSYMTAB));

        /* Got it. Report to the user and return the necessary data */
        (void) elfedit_sec_issymtab(obj_state, symsec, 1, NULL);
        type_name = elfedit_atoconst_value_to_str(ELFEDIT_CONST_SHT_ALLSYMTAB,
            symsec->sec_shdr->sh_type, 1);
        elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_FNDSYMTAB),
            EC_WORD(symsec->sec_shndx), symsec->sec_name, type_name);
        *sym = (Sym *) symsec->sec_data->d_buf;
        *num = symsec->sec_shdr->sh_size / symsec->sec_shdr->sh_entsize;
        if (aux_info != NULL)
                *aux_info = symtab;
        return (symsec);
}



/*
 * Locate the extended symbol index section associated with a symbol
 * table section.
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      symsec - Symbol table section for which extended index
 *              index section is required.
 *      xshndx - Address of variable to recieve pointer to section index
 *              array data buffer.
 *      numxshndx - Address of variable to receive number of indices
 *              referenced by ndx.
 *
 * exit:
 *      On success, returns extended index section descriptor, and sets the
 *      variables referenced by xshndx, and numxshndx. On failure,
 *      does not return.
 *
 * note:
 *      Since the extended section index is found in the sec_xshndx field
 *      of the elfedit_section_t, the caller may be tempted to bypass this
 *      routine and access it directly. That temptation should be resisted,
 *      as this routine performs useful error checking, and also handles
 *      the issuing of the standard MSG_DEBUG messages.
 */
elfedit_section_t *
elfedit_sec_getxshndx(elfedit_obj_state_t *obj_state,
    elfedit_section_t *symsec, Word **xshndx, Word *num)
{
        elfedit_section_t       *xshndxsec;
        elfedit_symtab_t        *symtab;
        Word                    ndx;

        /* Sanity check: symsec must be a symbol table */
        (void) elfedit_sec_issymtab(obj_state, symsec, 1, NULL);

        symtab = obj_state->os_symtab;
        for (ndx = 0; ndx < obj_state->os_symtabnum; ndx++, symtab++)
                if (symsec->sec_shndx == symtab->symt_shndx)
                        break;

        /*
         * Issue error if the symbol table lacks an extended index section.
         * The caller won't ask unless they encounter an SHN_XINDEX value,
         * in which case the lack of the index section denotes a corrupt
         * ELF file.
         */
        if ((ndx == obj_state->os_symtabnum) ||
            (symtab->symt_xshndx == SHN_UNDEF))
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOXSHSEC),
                    EC_WORD(symsec->sec_shndx), symsec->sec_name);

        /* Got it. Report to the user and return the necessary data */
        xshndxsec = &obj_state->os_secarr[symtab->symt_xshndx];
        elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_FNDXSHNDX),
            EC_WORD(symsec->sec_shndx), symsec->sec_name,
            EC_WORD(xshndxsec->sec_shndx), xshndxsec->sec_name);
        *xshndx = (Word *) xshndxsec->sec_data->d_buf;
        *num = xshndxsec->sec_shdr->sh_size / xshndxsec->sec_shdr->sh_entsize;
        return (xshndxsec);
}



/*
 * Locate the versym section associated with a symbol table section.
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      symsec - Symbol table section for which extended index
 *              index section is required.
 *      versym - Address of variable to recieve pointer to section index
 *              array data buffer.
 *      numversym - Address of variable to receive number of indices
 *              referenced by ndx.
 *
 * exit:
 *      On success, returns versym section descriptor, and sets the
 *      variables referenced by versym, and numversym. On failure,
 *      does not return.
 *
 * note:
 *      Since the versym section index is found in the sec_versym field
 *      of the elfedit_section_t, the caller may be tempted to bypass this
 *      routine and access it directly. That temptation should be resisted,
 *      as this routine performs useful error checking, and also handles
 *      the issuing of the standard MSG_DEBUG messages.
 */
elfedit_section_t *
elfedit_sec_getversym(elfedit_obj_state_t *obj_state,
    elfedit_section_t *symsec, Versym **versym, Word *num)
{
        elfedit_section_t       *versymsec;
        elfedit_symtab_t        *symtab;
        Word                    ndx;

        /* Sanity check: symsec must be a symbol table */
        (void) elfedit_sec_issymtab(obj_state, symsec, 1, NULL);

        symtab = obj_state->os_symtab;
        for (ndx = 0; ndx < obj_state->os_symtabnum; ndx++, symtab++)
                if (symsec->sec_shndx == symtab->symt_shndx)
                        break;
        /*
         * Issue error if the symbol table lacks a versym section.
         * The caller won't ask unless they see a non-null
         * aux.symtab.sec_versym, so this should not be a problem.
         */
        if ((ndx == obj_state->os_symtabnum) ||
            (symtab->symt_versym == SHN_UNDEF))
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOVERSYMSEC),
                    EC_WORD(symsec->sec_shndx), symsec->sec_name);

        /* Got it. Report to the user and return the necessary data */
        versymsec = &obj_state->os_secarr[symtab->symt_versym];
        elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_FNDVERSYM),
            EC_WORD(symsec->sec_shndx), symsec->sec_name,
            EC_WORD(versymsec->sec_shndx), versymsec->sec_name);
        *versym = (Versym *) versymsec->sec_data->d_buf;
        *num = versymsec->sec_shdr->sh_size / versymsec->sec_shdr->sh_entsize;
        return (versymsec);
}



/*
 * Locate the string table specified by shndx for this object.
 *
 * entry:
 *      obj_state - Object state.
 *      shndx - Section index for string table section
 *      allow_shflags - If False (0), only sections of type SHT_STRTAB
 *              are accepted as being string tables, and any other type
 *              will fail. If True (1), non-stringtable sections with
 *              their SHF_STRINGS flag set are also accepted.
 *
 * exit:
 *      Returns section descriptor on success. On failure, does not return.
 *
 * note:
 *      At this time, we can only support SHF_STRINGS sections that
 *      use single byte characters and which do not require alignment >1.
 *      SHF_STRINGS sections that have multi-byte characters or alignment
 *      are not currently supported and will draw an error even if
 *      allow_shflags is True.
 */
elfedit_section_t *
elfedit_sec_getstr(elfedit_obj_state_t *obj_state, Word shndx,
    int allow_shflags)
{
        elfedit_section_t *strsec;

        if ((shndx == 0) || (shndx >= obj_state->os_shnum))
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_STRSHNDX),
                    EC_WORD(shndx), EC_WORD(obj_state->os_shnum - 1));

        strsec = &obj_state->os_secarr[shndx];
        if (strsec->sec_shdr->sh_type == SHT_STRTAB) {
                elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_FNDSTRTAB),
                    EC_WORD(shndx), strsec->sec_name);
        } else if (allow_shflags &&
            ((strsec->sec_shdr->sh_flags & SHF_STRINGS) != 0) &&
            (strsec->sec_shdr->sh_entsize <= 1) &&
            (strsec->sec_shdr->sh_addralign <= 1)) {
                elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_FNDSTRTABFL),
                    EC_WORD(shndx), strsec->sec_name);
        } else {
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOTSTRSH),
                    EC_WORD(shndx), strsec->sec_name);
        }

        return (strsec);
}


/*
 * Returns the offset of the specified string from within
 * the given section.
 *
 * entry:
 *      sec - Descriptor for section
 *      tail_ign - If non-zero, the # of characters at the end of the
 *              section that should be ignored and not searched.
 *      str - String we are looking for.
 *      ret_offset - Address of variable to receive result
 *
 * exit:
 *      Returns 1 for success, and 0 for failure. If successful, *ret_offset
 *      is set to the offset of the found string within the section.
 */
int
elfedit_sec_findstr(elfedit_section_t *sec, Word tail_ign,
    const char *str, Word *ret_offset)
{
        int             str_fch = *str; /* First character in str */
        Word            len;            /* # characters in table */
        char            *s;             /* ptr to strings within table */
        const char      *tail;          /* 1 past final character of table */


        /* Size of the section, minus the reserved part (if any) at the end */
        len = sec->sec_shdr->sh_size - tail_ign;

        /*
         * Move through the section character by character looking for
         * a match. Moving character by character instead of skipping
         * from NULL terminated string to string allows us to use
         * the tails longer strings (i.e. we want "bar", and "foobar" exists).
         * We look at the first character manually before calling strcmp()
         * to lower the cost of this approach.
         */
        s = (char *)sec->sec_data->d_buf;
        tail = s + len;
        for (; s <= tail; s++) {
                if ((*s == str_fch) && (strcmp(s, str) == 0)) {
                        *ret_offset = s - (char *)sec->sec_data->d_buf;
                        elfedit_msg(ELFEDIT_MSG_DEBUG,
                            MSG_INTL(MSG_DEBUG_EXISTSTR),
                            EC_WORD(sec->sec_shndx), sec->sec_name,
                            EC_WORD(*ret_offset), s);
                        return (1);
                }
        }

        /* Didn't find it. Report failure */
        return (0);
}


/*
 * Locate the DT_SUNW_STRPAD element of the given dynamic section if
 * it exists.
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      dynsec - Dynamic section descriptor
 *      dyn_strpad - Address of variable to receive the results.
 *              The caller is responsible for calling elfedit_dyn_elt_init()
 *              on this variable beforehand.
 *
 * exit:
 *      The dynamic section is searched, and if a DT_SUNW_STRPAD element
 *      is found, dyn_strpad is updated via elfedit_dyn_elt_save() to
 *      reference it.
 *
 *      Returns the final value of dyn_strpad->dn_seen.
 */
int
elfedit_dynstr_getpad(elfedit_obj_state_t *obj_state, elfedit_section_t *dynsec,
    elfedit_dyn_elt_t *dyn_strpad)
{
        Word numdyn = dynsec->sec_shdr->sh_size / dynsec->sec_shdr->sh_entsize;
        Dyn     *dyn = (Dyn *) dynsec->sec_data->d_buf;
        Word    i;

        /*
         * DT_SUNW_STRPAD is specific to the Solaris OSABI.
         * If the object is tagged otherwise, don't even look.
         */
        if (!elfedit_test_osabi(obj_state, ELFOSABI_SOLARIS, 0))
                return (dyn_strpad->dn_seen);

        /* Go through dynamic section tags and find the STRPAD entry */
        for (i = 0; i < numdyn; i++) {
                if (dyn[i].d_tag == DT_SUNW_STRPAD) {
                        elfedit_dyn_elt_save(dyn_strpad, i, &dyn[i]);
                        break;
                }
        }

        return (dyn_strpad->dn_seen);
}



/*
 * Given references to the dynamic section, its string table,
 * and the DT_SUNW_STRPAD entry of the dynamic section, returns
 * the offset of the specified string from within the given string table,
 * adding it if possible.
 *
 * entry:
 *      dynsec - Dynamic section descriptor
 *      strsec - Descriptor for string table assocated with dynamic section
 *      dyn_strpad - DT_SUNW_STRPAD element from dynamic section
 *      str - String we are looking for.
 *
 * exit:
 *      On success, the offset of the given string within the string
 *      table is returned. If the string does not exist within the table,
 *      but there is a valid DT_SUNW_STRPAD reserved section, then we
 *      add the string, and update the dynamic section STRPAD element
 *      to reflect the space we use.
 *
 *      This routine does not return on failure.
 */
Word
elfedit_dynstr_insert(elfedit_section_t *dynsec, elfedit_section_t *strsec,
    elfedit_dyn_elt_t *dyn_strpad, const char *str)
{
        Word    ins_off;        /* Table offset to 1st reserved byte */
        char    *s;             /* ptr to strings within table */
        Word    len;            /* Length of str inc. NULL byte */
        Word    tail_ign;       /* # reserved bytes at end of strtab */


        tail_ign = dyn_strpad->dn_seen ? dyn_strpad->dn_dyn.d_un.d_val : 0;

        /* Does the string already existin the string table? */
        if (elfedit_sec_findstr(strsec, tail_ign, str, &len))
                return (len);

        /*
         * The desired string does not already exist. Do we have
         * room to add it?
         */
        len = strlen(str) + 1;
        if (!dyn_strpad->dn_seen || (len > dyn_strpad->dn_dyn.d_un.d_val))
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOSTRPAD),
                    EC_WORD(strsec->sec_shdr->sh_link),
                    strsec->sec_name);


        /*
         * We will add the string at the first byte of the reserved NULL
         * area at the end. The DT_SUNW_STRPAD dynamic element gives us
         * the size of that reserved space.
         */
        ins_off = strsec->sec_shdr->sh_size - tail_ign;
        s = ((char *)strsec->sec_data->d_buf) + ins_off;

        /* Announce the operation */
        elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_ADDSTR),
            EC_WORD(strsec->sec_shndx), strsec->sec_name,
            EC_WORD(ins_off), EC_WORD(len),
            EC_WORD(dyn_strpad->dn_dyn.d_un.d_val), str);

        /*
         * Copy the string into the pad area at the end, and
         * mark the data area as dirty so libelf will flush our
         * changes to the string data.
         */
        (void) strncpy(s, str, dyn_strpad->dn_dyn.d_un.d_val);
        elfedit_modified_data(strsec);

        /* Update the DT_STRPAD dynamic entry */
        dyn_strpad->dn_dyn.d_un.d_val -= len;
        ((Dyn *) dynsec->sec_data->d_buf)[dyn_strpad->dn_ndx] =
            dyn_strpad->dn_dyn;
        elfedit_modified_data(dynsec);

        return (ins_off);
}


/*
 * Test to see if a call to elfedit_strtab_insert() will succeed.
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      strsec - Descriptor for string table
 *      dynsec - NULL, or descriptor for dynamic section. Providing
 *              a non-NULL value here will prevent elfedit_strtab_insert()
 *              from looking it up, and the duplicate debug message that
 *              would result.
 *      str - String we are looking for.
 *
 * exit:
 *      If the string exists within the string table, or if an attempt
 *      to insert it will be successful, quietly return. Otherwise, throw
 *      the error elfedit_strtab_insert() would throw under the
 *      same circumstances.
 *
 */
void
elfedit_strtab_insert_test(elfedit_obj_state_t *obj_state,
    elfedit_section_t *strsec, elfedit_section_t *dynsec, const char *str)
{
        Word    len;            /* Length of str inc. NULL byte */
        int                     is_dynstr = 0;
        Word                    tail_ign = 0;


        /*
         * The dynstr is a special case, because we can add strings
         * to it under certain circumstances. So, we look for the
         * dynamic section, and if it exists, compare its sh_link to
         * the string section index. If they match, it is the dynstr,
         * and we use elfedit_dynstr_insert() to do the work.
         */
        if (dynsec == NULL) {
                if (obj_state->os_dynndx != SHN_UNDEF) {
                        dynsec = &obj_state->os_secarr[obj_state->os_dynndx];
                        if ((dynsec->sec_shdr->sh_type == SHT_DYNAMIC) &&
                            (strsec->sec_shndx == dynsec->sec_shdr->sh_link)) {
                                is_dynstr = 1;
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_FNDDYN),
                                    EC_WORD(dynsec->sec_shndx),
                                    dynsec->sec_name);
                        }
                }
        } else {
                if (strsec->sec_shndx == dynsec->sec_shdr->sh_link)
                        is_dynstr = 1;
        }


        if (is_dynstr) {
                elfedit_dyn_elt_t dyn_strpad;

                /* Determine the size of the STRPAD area, if any */
                elfedit_dyn_elt_init(&dyn_strpad);
                if (elfedit_dynstr_getpad(obj_state, dynsec, &dyn_strpad) != 0)
                        tail_ign = dyn_strpad.dn_dyn.d_un.d_val;
        }

        /*
         * If the string is already in the string table, we
         * can't fail.
         */
        if (elfedit_sec_findstr(strsec, tail_ign, str, &len) != 0)
                return;

        /*
         * It's not in the table, but if this is the dynstr, and
         * there is enough room, we will be able to add it.
         */
        if (is_dynstr && (tail_ign > strlen(str)))
                return;

        /* Can't do it. Issue error */
        elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOSTRPAD),
            EC_WORD(strsec->sec_shdr->sh_link), strsec->sec_name);
}


/*
 * Returns the offset of the specified string from within
 * the given string table, adding it if possible.
 *
 * entry:
 *      obj_state - Object state for open object to query.
 *      strsec - Descriptor for string table
 *      dynsec - NULL, or descriptor for dynamic section. Providing
 *              a non-NULL value here will prevent elfedit_strtab_insert()
 *              from looking it up, and the duplicate debug message that
 *              would result.
 *      str - String we are looking for.
 *
 * exit:
 *      On success, the offset of the given string within the string
 *      table is returned. If the string does not exist within the table,
 *      and it is possible to add it, elfedit_strtab_insert() will
 *      add the string, and then return the offset.
 *
 *      If the string does not exist in the string table, and cannot
 *      be added, this routine issues an error message and does not
 *      return to the caller.
 */
Word
elfedit_strtab_insert(elfedit_obj_state_t *obj_state, elfedit_section_t *strsec,
    elfedit_section_t *dynsec, const char *str)
{
        Word    len;            /* Length of str inc. NULL byte */
        int                     is_dynstr = 0;
        elfedit_dyn_elt_t       dyn_strpad;


        /*
         * The dynstr is a special case, because we can add strings
         * to it under certain circumstances. So, we look for the
         * dynamic section, and if it exists, compare its sh_link to
         * the string section index. If they match, it is the dynstr,
         * and we use elfedit_dynstr_insert() to do the work.
         */
        if (dynsec == NULL) {
                if (obj_state->os_dynndx != SHN_UNDEF) {
                        dynsec = &obj_state->os_secarr[obj_state->os_dynndx];
                        if ((dynsec->sec_shdr->sh_type == SHT_DYNAMIC) &&
                            (strsec->sec_shndx == dynsec->sec_shdr->sh_link)) {
                                is_dynstr = 1;
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_FNDDYN),
                                    EC_WORD(dynsec->sec_shndx),
                                    dynsec->sec_name);
                        }
                }
        } else {
                if (strsec->sec_shndx == dynsec->sec_shdr->sh_link)
                        is_dynstr = 1;
        }

        if (is_dynstr) {
                elfedit_dyn_elt_init(&dyn_strpad);
                (void) elfedit_dynstr_getpad(obj_state, dynsec, &dyn_strpad);
                return (elfedit_dynstr_insert(dynsec, strsec,
                    &dyn_strpad, str));
        }

        /*
         * This is not the dynstr, so we are limited to strings that
         * already exist within it. Try to find one.
         */
        if (elfedit_sec_findstr(strsec, 0, str, &len))
                return (len);

        /* Can't do it. Issue error */
        elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOSTRPAD),
            EC_WORD(strsec->sec_shdr->sh_link), strsec->sec_name);
        /*NOTREACHED*/

        return (0);
}


/*
 * Return the string found at the given offset within the specified
 * string table.
 *
 * entry:
 *      strsec - Section descriptor for string table section
 *      offset - Offset of desired string in string table
 *      msg_type - ELFEDIT_MSG_ type code to use with message
 *              issued if offset is out of range for the symbol table.
 *      debug_msg - True if should issue debug message for string found.
 *
 * exit:
 *      If the offset is within the section, the string pointer
 *      is returned. Otherwise an error is issued using msg_type
 *      to determine the type of message. If this routine retains
 *      control after the message is issued, a safe string is returned.
 */
const char *
elfedit_offset_to_str(elfedit_section_t *strsec, Word offset,
    elfedit_msg_t msg_type, int debug_msg)
{
        const char *str;

        /* Make sure it is a string table section */
        if (strsec->sec_shdr->sh_type != SHT_STRTAB)
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOTSTRSH),
                    EC_WORD(strsec->sec_shndx), strsec->sec_name);

        /* Ensure the offset is in range */
        if (offset >= strsec->sec_data->d_size) {
                elfedit_msg(msg_type, MSG_INTL(MSG_ERR_BADSTROFF),
                    EC_WORD(strsec->sec_shndx), strsec->sec_name,
                    EC_WORD(offset), EC_WORD(strsec->sec_data->d_size - 1));
                /*
                 * If the msg_type is a type that returns, give the
                 * user a safe string to use.
                 */
                str = MSG_INTL(MSG_BADSYMOFFSETNAM);
        } else {
                /* Return the string */
                str = ((const char *)strsec->sec_data->d_buf) + offset;
        }

        if (debug_msg)
                elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_FNDSTR),
                    EC_WORD(strsec->sec_shndx), strsec->sec_name,
                    EC_WORD(offset), str);
        return (str);
}


/*
 * Given a string table section, and a dynamic section entry
 * that supplies a string offset, return the string found at
 * the given offset. This routine is a convenience wrapper on
 * elfedit_offset_to_str().
 *
 * exit:
 *      As per elfedit_offset_to_str().
 */
const char *
elfedit_dyn_offset_to_str(elfedit_section_t *strsec, elfedit_dyn_elt_t *dynelt)
{
        return (elfedit_offset_to_str(strsec, dynelt->dn_dyn.d_un.d_val,
            ELFEDIT_MSG_ERR, 0));
}


/*
 * Given a section, fabricate a string for the form:
 *
 *      "[#: name]"
 *
 * as used at the beginning of debug messages. A pointer to static
 * memory is returned, and is good until the next such call.
 */
const char *
elfedit_sec_msgprefix(elfedit_section_t *sec)
{
        static char     *buf;
        static size_t   bufsize;

        size_t          need;

        need = 64 + strlen(sec->sec_name);
        if (need > bufsize) {
                buf = elfedit_realloc(MSG_INTL(MSG_ALLOC_SECMSGPRE), buf, need);
                bufsize = need;
        }

        (void) snprintf(buf, bufsize, MSG_ORIG(MSG_FMT_SECMSGPRE),
            EC_WORD(sec->sec_shndx), sec->sec_name);

        return (buf);
}