/*
 * 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        <stdio.h>
#include        <unistd.h>
#include        <elfedit.h>
#include        <strings.h>
#include        <debug.h>
#include        <conv.h>
#include        <syminfo_msg.h>



/*
 * This module uses shared code for several of the commands.
 * It is sometimes necessary to know which specific command
 * is active.
 */
typedef enum {
        SYMINFO_CMD_T_DUMP =            0,      /* syminfo:dump */

        SYMINFO_CMD_T_SI_BOUNDTO =      1,      /* syminfo:si_boundto */
        SYMINFO_CMD_T_SI_FLAGS =        2       /* syminfo:si_boundto */
} SYMINFO_CMD_T;



#ifndef _ELF64
/*
 * We supply this function for the msg module. Only one copy is needed.
 */
const char *
_syminfo_msg(Msg mid)
{
        return (gettext(MSG_ORIG(mid)));
}

#endif



/*
 * 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));
}



/*
 * The sym_opt_t enum specifies a bit value for every optional
 * argument allowed by a command in this module.
 */
typedef enum {
        SYMINFO_OPT_F_AND =     1,      /* -and: AND (&) values to dest */
        SYMINFO_OPT_F_CMP =     2,      /* -cmp: Complement (~) values */
        SYMINFO_OPT_F_NEEDED =  4,      /* -needed: arg is name of object to */
                                        /*      be referenced via DT_NEEDED */
                                        /*      dynamic entry */
        SYMINFO_OPT_F_OR =      8,      /* -or: OR (|) values to dest */
        SYMINFO_OPT_F_SYMNDX =  16      /* -symndx: Sym specified by index */
} syminfo_opt_t;


/*
 * A variable of type ARGSTATE is used by each command to maintain
 * information about the syminfo section being used, as and for any
 * auxiliary sections that are related to it. This helps us to ensure
 * that we only fetch each section a single time:
 *      - More efficient
 *      - Prevents multiple ELFEDIT_MSG_DEBUG messages from
 *        being produced for a given section.
 */
typedef struct {
        elfedit_obj_state_t     *obj_state;
        syminfo_opt_t           optmask;        /* Mask of options used */
        int                     argc;           /* # of plain arguments */
        const char              **argv;         /* Plain arguments */
        struct {                                /* Syminfo */
                elfedit_section_t       *sec;
                Syminfo                 *data;
                Word                    n;
        } syminfo;
        struct {                                /* Symbol table */
                elfedit_section_t       *sec;
                Sym                     *data;
                Word                    n;
        } sym;
        struct {                                /* String table */
                elfedit_section_t       *sec;
        } str;
        struct {                                /* Dynamic section */
                elfedit_section_t       *sec;
                Dyn                     *data;
                Word                    n;
        } dynamic;
} ARGSTATE;



/*
 * Standard argument processing for syminfo module
 *
 * entry
 *      obj_state, argc, argv - Standard command arguments
 *      optmask - Mask of allowed optional arguments.
 *      argstate - Address of ARGSTATE block to be initialized
 *
 * exit:
 *      On success, *argstate is initialized. On error,
 *      an error is issued and this routine does not return.
 *
 * note:
 *      Only the syminfo section is initially referenced by
 *      argstate. Use the argstate_add_XXX() routines below to
 *      access any other sections needed.
 */
static void
process_args(elfedit_obj_state_t *obj_state, int argc, const char *argv[],
    SYMINFO_CMD_T cmd, ARGSTATE *argstate)
{
        elfedit_getopt_state_t  getopt_state;
        elfedit_getopt_ret_t    *getopt_ret;

        bzero(argstate, sizeof (*argstate));
        argstate->obj_state = obj_state;

        elfedit_getopt_init(&getopt_state, &argc, &argv);

        /* Add each new option to the options mask */
        while ((getopt_ret = elfedit_getopt(&getopt_state)) != NULL)
                argstate->optmask |= getopt_ret->gor_idmask;

        /*
         * Usage error if there are too many plain arguments.
         *      - syminfo:dump accepts a single argument
         *      - syminfo:si_boundto accepts 2 arguments
         *      - syminfo:si_flags accepts an unbounded number
         */
        if (((cmd == SYMINFO_CMD_T_DUMP) && (argc > 1)) ||
            ((cmd == SYMINFO_CMD_T_SI_BOUNDTO) && (argc > 2)))
                elfedit_command_usage();

        /* If there may be an arbitrary amount of output, use a pager */
        if (argc == 0)
                elfedit_pager_init();

        /* Return the updated values of argc/argv */
        argstate->argc = argc;
        argstate->argv = argv;

        /* Locate the syminfo section */
        argstate->syminfo.sec = elfedit_sec_getsyminfo(obj_state,
            &argstate->syminfo.data, &argstate->syminfo.n);
}



/*
 * We maintain the state of the current syminfo table in a ARGSTATE
 * structure. A syminfo is related to the dynamic symbol table, and
 * can reference the dynamic section of the object. We don't look those
 * things up unless we actually need them, both to be efficient, and
 * to prevent duplicate ELFEDIT_MSG_DEBUG messages from being issued
 * as they are located. Hence, process_args() is used to initialze the
 * state block with just the syminfo section, and then one of the
 * argstate_add_XXX() functions is used as needed to fetch the
 * additional sections.
 *
 * entry:
 *      argstate - State block for current symbol table.
 *
 * exit:
 *      If the needed auxiliary section is not found, an error is
 *      issued and the argstate_add_XXX() routine does not return.
 *      Otherwise, the fields in argstate have been filled in, ready
 *      for use.
 *
 */
static void
argstate_add_sym(ARGSTATE *argstate)
{
        if (argstate->sym.sec != NULL)
                return;

        argstate->sym.sec = elfedit_sec_getsymtab(argstate->obj_state,
            1, argstate->syminfo.sec->sec_shdr->sh_link, NULL,
            &argstate->sym.data, &argstate->sym.n, NULL);
}
static void
argstate_add_str(ARGSTATE *argstate)
{
        if (argstate->str.sec != NULL)
                return;

        argstate_add_sym(argstate);
        argstate->str.sec = elfedit_sec_getstr(argstate->obj_state,
            argstate->sym.sec->sec_shdr->sh_link, 0);
}
static void
argstate_add_dynamic(ARGSTATE *argstate)
{
        if (argstate->dynamic.sec != NULL)
                return;

        argstate->dynamic.sec = elfedit_sec_getdyn(argstate->obj_state,
            &argstate->dynamic.data, &argstate->dynamic.n);
}



/*
 * Display syminfo section entries in the style used by elfdump.
 *
 * entry:
 *      argstate - State block for current symbol table.
 *      ndx - Index of first symbol to display
 *      cnt - Number of symbols to display
 */
static void
dump_syminfo(ARGSTATE *argstate, Word ndx, Word cnt)
{
        Syminfo                 *syminfo;
        Sym                     *sym;
        Dyn                     *dyn;

        syminfo = argstate->syminfo.data + ndx;

        argstate_add_sym(argstate);
        sym = argstate->sym.data + ndx;

        argstate_add_str(argstate);

        argstate_add_dynamic(argstate);
        dyn = argstate->dynamic.data;

        /*
         * Loop through the syminfo entries.
         */
        Elf_syminfo_title(0);

        for (; cnt-- > 0; ndx++, syminfo++, sym++) {
                const char      *needed = NULL, *name;

                name = elfedit_offset_to_str(argstate->str.sec,
                    sym->st_name, ELFEDIT_MSG_ERR, 0);

                if ((syminfo->si_boundto < SYMINFO_BT_LOWRESERVE) &&
                    (syminfo->si_boundto < argstate->dynamic.n) &&
                    ((dyn[syminfo->si_boundto].d_tag == DT_NEEDED) ||
                    (dyn[syminfo->si_boundto].d_tag == DT_USED)))
                        needed = elfedit_offset_to_str(argstate->str.sec,
                            dyn[syminfo->si_boundto].d_un.d_val,
                            ELFEDIT_MSG_ERR, 0);
                else
                        needed = MSG_ORIG(MSG_STR_EMPTY);

                Elf_syminfo_entry(0, ndx, syminfo, name, needed);
        }
}



/*
 * Print syminfo values, taking the calling command, and output style
 * into account.
 *
 * entry:
 *      cmd - SYMINFO_CMD_T_* value giving identify of caller
 *      autoprint - If True, output is only produced if the elfedit
 *              autoprint flag is set. If False, output is always produced.
 *      argstate - State block for current symbol table.
 *      ndx - Index of first symbol to display
 *      cnt - Number of symbols to display
 */
static void
print_syminfo(SYMINFO_CMD_T cmd, int autoprint, ARGSTATE *argstate,
    Word ndx, Word cnt)
{
        elfedit_outstyle_t      outstyle;
        Syminfo                 *syminfo;

        if ((autoprint && ((elfedit_flags() & ELFEDIT_F_AUTOPRINT) == 0)) ||
            (cnt == 0))
                return;

        /*
         * Pick an output style. syminfo:dump is required to use the default
         * style. The other commands use the current output style.
         */
        outstyle = (cmd == SYMINFO_CMD_T_DUMP) ?
            ELFEDIT_OUTSTYLE_DEFAULT : elfedit_outstyle();

        /*
         * If doing default output, use elfdump style where we
         * show all symbol attributes. In this case, the command
         * that called us doesn't matter
         */
        if (outstyle == ELFEDIT_OUTSTYLE_DEFAULT) {
                dump_syminfo(argstate, ndx, cnt);
                return;
        }

        syminfo = argstate->syminfo.data;

        switch (cmd) {
        case SYMINFO_CMD_T_SI_BOUNDTO:
                if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
                        /* Find the dynamic section and string table */
                        argstate_add_dynamic(argstate);
                        argstate_add_str(argstate);
                }

                for (syminfo += ndx; cnt--; syminfo++) {
                        Half bndto = syminfo->si_boundto;

                        if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
                                const char      *str = NULL;

                                switch (bndto) {
                                case SYMINFO_BT_SELF:
                                        str = elfedit_atoconst_value_to_str(
                                            ELFEDIT_CONST_SYMINFO_BT,
                                            SYMINFO_BT_SELF, 1);
                                        break;
                                case SYMINFO_BT_PARENT:
                                        str = elfedit_atoconst_value_to_str(
                                            ELFEDIT_CONST_SYMINFO_BT,
                                            SYMINFO_BT_PARENT, 1);
                                        break;
                                case SYMINFO_BT_NONE:
                                        str = elfedit_atoconst_value_to_str(
                                            ELFEDIT_CONST_SYMINFO_BT,
                                            SYMINFO_BT_NONE, 1);
                                        break;
                                }
                                if ((str == NULL) &&
                                    (bndto < SYMINFO_BT_LOWRESERVE) &&
                                    (argstate->dynamic.sec != NULL) &&
                                    (bndto < argstate->dynamic.n) &&
                                    (argstate->dynamic.data[bndto].d_tag ==
                                    DT_NEEDED))
                                        str = elfedit_offset_to_str(
                                            argstate->str.sec,
                                            argstate->dynamic.data[bndto].
                                            d_un.d_val, ELFEDIT_MSG_ERR, 0);

                                if (str != NULL) {
                                        elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
                                            str);
                                        continue;
                                }
                        }

                        /*
                         * If we reach this point, we are either in numeric
                         * mode, or we were unable to find a string above.
                         * In either case, output as integer.
                         */
                        elfedit_printf(MSG_ORIG(MSG_FMT_WORDVALNL),
                            EC_WORD(bndto));
                }
                break;

        case SYMINFO_CMD_T_SI_FLAGS:
                for (syminfo += ndx; cnt--; syminfo++) {
                        if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
                                Conv_syminfo_flags_buf_t buf;

                                elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
                                    conv_syminfo_flags(syminfo->si_flags,
                                    CONV_FMT_NOBKT, &buf));
                        } else {
                                elfedit_printf(MSG_ORIG(MSG_FMT_HEXNUMNL),
                                    EC_WORD(syminfo->si_flags));
                        }
                }
                break;
        }
}


/*
 * Convert the given argument string into a symbol table index.
 *
 * entry:
 *      argstate - State block for current symbol table.
 *      arg - String containing symbol index argument.
 *
 * exit:
 *      On success, returns the symbol index. On failure, an error
 *      is issued and this routine does not return.
 */
static Word
arg_to_symndx(ARGSTATE *argstate, const char *arg)
{
        Word symndx;

        /*
         * If the -symndx option was specified, arg is an index
         * into the symbol table.
         */
        if (argstate->optmask & SYMINFO_OPT_F_SYMNDX)
                return (elfedit_atoui_range(arg, MSG_ORIG(MSG_STR_SYM),
                    0, argstate->syminfo.n - 1, NULL));

        /*
         * arg is a symbol name. Return the index of the first symbol
         * that matches
         */
        argstate_add_sym(argstate);
        argstate_add_str(argstate);

        (void) elfedit_name_to_symndx(argstate->sym.sec,
            argstate->str.sec, arg, ELFEDIT_MSG_ERR, &symndx);

        return (symndx);
}


/*
 * Given a string argument representing an object, return the index of
 * the dynamic section that should be used for the si_boundto value.
 */
static Half
needed_to_boundto(ARGSTATE *argstate, const char *arg)
{
        Conv_inv_buf_t          inv_buf;
        elfedit_dyn_elt_t       strpad_elt;
        elfedit_dyn_elt_t       null_elt;
        elfedit_section_t       *dynsec;
        Word                    null_cnt;
        Dyn                     *dyn;
        Word                    str_offset, ndx, numdyn;
        int                     have_string;

        argstate_add_str(argstate);
        argstate_add_dynamic(argstate);
        dynsec = argstate->dynamic.sec;
        numdyn = argstate->dynamic.n;

        /* Locate DT_SUNW_STRPAD element if present and locate the DT_NULLs */
        elfedit_dyn_elt_init(&strpad_elt);
        elfedit_dyn_elt_init(&null_elt);
        null_cnt = 0;
        strpad_elt.dn_dyn.d_un.d_val = 0;
        dyn = argstate->dynamic.data;
        for (ndx = 0; ndx < numdyn; dyn++, ndx++) {
                switch (dyn->d_tag) {
                case DT_NULL:
                        /* Count all the nulls, remember the first one */
                        null_cnt++;
                        if (!null_elt.dn_seen)
                                elfedit_dyn_elt_save(&null_elt, ndx, dyn);
                        break;

                case DT_SUNW_STRPAD:
                        if (elfedit_test_osabi(argstate->obj_state,
                            ELFOSABI_SOLARIS, 0))
                                elfedit_dyn_elt_save(&strpad_elt, ndx, dyn);
                        break;
                }
        }

        /*
         * Look up the string in the string table and get its offset. If
         * this succeeds, then it is possible that there is a DT_NEEDED
         * dynamic entry that references it.
         */
        have_string = elfedit_sec_findstr(argstate->str.sec,
            strpad_elt.dn_dyn.d_un.d_val, arg, &str_offset) != 0;
        if (have_string) {
                dyn = argstate->dynamic.data;
                for (ndx = 0; ndx < numdyn; dyn++, ndx++) {
                        if (((dyn->d_tag == DT_NEEDED) ||
                            (dyn->d_tag == DT_USED)) &&
                            (dyn->d_un.d_val == str_offset))
                                goto done;
                }
        }

        /*
         * It doesn't already exist. We might be able to add a DT_NEEDED
         * to the dynamic section if an extra DT_NULL is available.
         * Otherwise, we have to fail here.
         */
        if (null_cnt < 2)
                elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOEXTRANULL),
                    EC_WORD(dynsec->sec_shndx), dynsec->sec_name);

        /*
         * If the string is not already in the string table, try to
         * insert it. If it succeeds, we will convert the DT_NULL.
         * Otherwise, an error will be issued and control will not
         * return here.
         */
        if (!have_string)
                str_offset = elfedit_dynstr_insert(dynsec,
                    argstate->str.sec, &strpad_elt, arg);

        /* Convert the extra DT_NULL */
        ndx = null_elt.dn_ndx;
        elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_CONVNULL),
            EC_WORD(dynsec->sec_shndx), dynsec->sec_name, EC_WORD(ndx),
            conv_dyn_tag(DT_NEEDED,
            argstate->obj_state->os_ehdr->e_ident[EI_OSABI],
            argstate->obj_state->os_ehdr->e_machine,
            0, &inv_buf));
        dyn = argstate->dynamic.data + ndx;
        dyn->d_tag = DT_NEEDED;
        dyn->d_un.d_val = str_offset;
        elfedit_modified_data(dynsec);

done:
        elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_FNDNEEDED),
            dynsec->sec_shndx, dynsec->sec_name, ndx, arg);
        return (ndx);
}

/*
 * Common body for the syminfo: module commands. These commands
 * share a large amount of common behavior, so it is convenient
 * to centralize things and use the cmd argument to handle the
 * small differences.
 *
 * entry:
 *      cmd - One of the SYMINFO_CMD_T_* constants listed above, specifying
 *              which command to implement.
 *      obj_state, argc, argv - Standard command arguments
 */
static elfedit_cmdret_t
cmd_body(SYMINFO_CMD_T cmd, elfedit_obj_state_t *obj_state,
    int argc, const char *argv[])
{
        ARGSTATE                argstate;
        Word                    ndx;
        Syminfo                 *syminfo;
        elfedit_cmdret_t        ret = ELFEDIT_CMDRET_NONE;

        process_args(obj_state, argc, argv, cmd, &argstate);

        /* If there are no arguments, dump the whole table and return */
        if (argstate.argc == 0) {
                print_syminfo(cmd, 0, &argstate, 0, argstate.syminfo.n);
                return (ELFEDIT_CMDRET_NONE);
        }

        /* The first argument is the symbol name/index */
        ndx = arg_to_symndx(&argstate, argstate.argv[0]);

        /* If there is a single argument, display that item and return */
        if (argstate.argc == 1) {
                print_syminfo(cmd, 0, &argstate, ndx, 1);
                return (ELFEDIT_CMDRET_NONE);
        }

        syminfo = &argstate.syminfo.data[ndx];

        /*
         * Syminfo [0] holds the value SYMINFO_CURRENT, as a versioning
         * technique. You're not supposed to mess with it.
         */
        if (ndx == 0)
                elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_CHGSYMINFO0),
                    EC_WORD(argstate.syminfo.sec->sec_shndx),
                    argstate.syminfo.sec->sec_name, EC_WORD(ndx));

        /* The second value supplies a new value for the item */
        switch (cmd) {
                /*
                 * SYMINFO_CMD_T_DUMP can't get here: It never has more than
                 * one argument, and is handled above.
                 */

        case SYMINFO_CMD_T_SI_BOUNDTO:
                {
                        const char *name = MSG_ORIG(MSG_CMD_SI_BOUNDTO);
                        Half boundto;

                        if (argstate.optmask & SYMINFO_OPT_F_NEEDED)
                                boundto = needed_to_boundto(&argstate,
                                    argstate.argv[1]);
                        else
                                boundto = elfedit_atoconst_range(
                                    argstate.argv[1], MSG_ORIG(MSG_STR_VALUE),
                                    0, 0xffff, ELFEDIT_CONST_SYMINFO_BT);

                        if (syminfo->si_boundto == boundto) {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_X_OK),
                                    argstate.syminfo.sec->sec_shndx,
                                    argstate.syminfo.sec->sec_name, ndx, name,
                                    syminfo->si_boundto);
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_X_CHG),
                                    argstate.syminfo.sec->sec_shndx,
                                    argstate.syminfo.sec->sec_name, ndx, name,
                                    syminfo->si_boundto, boundto);
                                ret = ELFEDIT_CMDRET_MOD;
                                syminfo->si_boundto = boundto;
                        }
                }
                break;

        case SYMINFO_CMD_T_SI_FLAGS:
                {
                        Conv_syminfo_flags_buf_t flags_buf1, flags_buf2;
                        const char *name = MSG_ORIG(MSG_CMD_SI_FLAGS);
                        Half flags = 0;
                        int i;

                        /* Collect the arguments */
                        for (i = 1; i < argstate.argc; i++)
                                flags |= (Word)
                                    elfedit_atoconst(argstate.argv[i],
                                    ELFEDIT_CONST_SYMINFO_FLG);

                        /* Complement the value? */
                        if (argstate.optmask & SYMINFO_OPT_F_CMP)
                                flags = ~flags;

                        /* Perform any requested bit operations */
                        if (argstate.optmask & SYMINFO_OPT_F_AND)
                                flags &= syminfo->si_flags;
                        else if (argstate.optmask & SYMINFO_OPT_F_OR)
                                flags |= syminfo->si_flags;

                        /* Set the value */
                        if (syminfo->si_flags == flags) {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_S_OK),
                                    argstate.syminfo.sec->sec_shndx,
                                    argstate.syminfo.sec->sec_name, ndx, name,
                                    conv_syminfo_flags(syminfo->si_flags,
                                    0, &flags_buf1));
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_S_CHG),
                                    argstate.syminfo.sec->sec_shndx,
                                    argstate.syminfo.sec->sec_name, ndx, name,
                                    conv_syminfo_flags(syminfo->si_flags,
                                    0, &flags_buf1),
                                    conv_syminfo_flags(flags, 0, &flags_buf2));
                                ret = ELFEDIT_CMDRET_MOD;
                                syminfo->si_flags = flags;
                        }
                }
                break;
        }

        /*
         * If we modified the syminfo section, tell libelf.
         */
        if (ret == ELFEDIT_CMDRET_MOD)
                elfedit_modified_data(argstate.syminfo.sec);

        /* Do autoprint */
        print_syminfo(cmd, 1, &argstate, ndx, 1);

        return (ret);
}




/*
 * Command completion functions for the various commands
 */
/*ARGSUSED*/
static void
cpl_si_boundto(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
    const char *argv[], int num_opt)
{
        int i;

        /*
         * If -needed option is not present, the second argument can be
         * an SYMINFO_BT_ value.
         */
        if (argc != (num_opt + 2))
                return;

        /* Is -needed there? If so, no completion is possible so return */
        for (i = 0; i < num_opt; i++)
                if (strcmp(argv[i], MSG_ORIG(MSG_STR_MINUS_NEEDED)) == 0)
                        return;

        elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SYMINFO_BT);
}

/*ARGSUSED*/
static void
cpl_si_flags(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
    const char *argv[], int num_opt)
{
        /* The second argument can be an SYMINFO_FLG_ value */
        if (argc == (num_opt + 2))
                elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SYMINFO_FLG);
}



/*
 * Implementation functions for the commands
 */
static elfedit_cmdret_t
cmd_dump(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
        return (cmd_body(SYMINFO_CMD_T_DUMP, obj_state, argc, argv));
}


static elfedit_cmdret_t
cmd_si_boundto(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
        return (cmd_body(SYMINFO_CMD_T_SI_BOUNDTO, obj_state, argc, argv));
}


static elfedit_cmdret_t
cmd_si_flags(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
{
        return (cmd_body(SYMINFO_CMD_T_SI_FLAGS, obj_state, argc, argv));
}




/*ARGSUSED*/
elfedit_module_t *
elfedit_init(elfedit_module_version_t version)
{
        /* sym:dump */
        static const char *name_dump[] = {
            MSG_ORIG(MSG_CMD_DUMP),
            MSG_ORIG(MSG_STR_EMPTY),    /* "" makes this the default command */
            NULL
        };
        static elfedit_cmd_optarg_t opt_dump[] = {
                { MSG_ORIG(MSG_STR_MINUS_SYMNDX),
                    /* MSG_INTL(MSG_OPTDESC_SYMNDX) */
                    ELFEDIT_I18NHDL(MSG_OPTDESC_SYMNDX), 0,
                    SYMINFO_OPT_F_SYMNDX, 0 },
                { NULL }
        };
        static elfedit_cmd_optarg_t arg_dump[] = {
                { MSG_ORIG(MSG_STR_SYM),
                    /* MSG_INTL(MSG_A1_SYM) */
                    ELFEDIT_I18NHDL(MSG_A1_SYM),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* sym:si_boundto */
        static const char *name_si_boundto[] = {
            MSG_ORIG(MSG_CMD_SI_BOUNDTO), NULL };
        static elfedit_cmd_optarg_t opt_si_boundto[] = {
                { MSG_ORIG(MSG_STR_MINUS_NEEDED),
                    /* MSG_INTL(MSG_OPTDESC_NEEDED) */
                    ELFEDIT_I18NHDL(MSG_OPTDESC_NEEDED), 0,
                    SYMINFO_OPT_F_NEEDED, 0 },
                { ELFEDIT_STDOA_OPT_O, 0,
                    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
                { MSG_ORIG(MSG_STR_MINUS_SYMNDX),
                    /* MSG_INTL(MSG_OPTDESC_SYMNDX) */
                    ELFEDIT_I18NHDL(MSG_OPTDESC_SYMNDX), 0,
                    SYMINFO_OPT_F_SYMNDX, 0 },
                { NULL }
        };
        static elfedit_cmd_optarg_t arg_si_boundto[] = {
                { MSG_ORIG(MSG_STR_SYM),
                    /* MSG_INTL(MSG_A1_SYM) */
                    ELFEDIT_I18NHDL(MSG_A1_SYM),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_VALUE),
                    /* MSG_INTL(MSG_A2_DESC_SI_BOUNDTO) */
                    ELFEDIT_I18NHDL(MSG_A2_DESC_SI_BOUNDTO),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* sym:si_flags */
        static const char *name_si_flags[] = {
            MSG_ORIG(MSG_CMD_SI_FLAGS), NULL };
        static elfedit_cmd_optarg_t opt_si_flags[] = {
                { ELFEDIT_STDOA_OPT_AND, 0, ELFEDIT_CMDOA_F_INHERIT,
                    SYMINFO_OPT_F_AND, SYMINFO_OPT_F_OR },
                { ELFEDIT_STDOA_OPT_CMP, 0,
                    ELFEDIT_CMDOA_F_INHERIT, SYMINFO_OPT_F_CMP, 0 },
                { ELFEDIT_STDOA_OPT_O, 0,
                    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
                { ELFEDIT_STDOA_OPT_OR, 0, ELFEDIT_CMDOA_F_INHERIT,
                    SYMINFO_OPT_F_OR, SYMINFO_OPT_F_AND },
                { MSG_ORIG(MSG_STR_MINUS_SYMNDX),
                    /* MSG_INTL(MSG_OPTDESC_SYMNDX) */
                    ELFEDIT_I18NHDL(MSG_OPTDESC_SYMNDX), 0,
                    SYMINFO_OPT_F_SYMNDX, 0 },
                { NULL }
        };
        static elfedit_cmd_optarg_t arg_si_flags[] = {
                { MSG_ORIG(MSG_STR_SYM),
                    /* MSG_INTL(MSG_A1_SYM) */
                    ELFEDIT_I18NHDL(MSG_A1_SYM),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_VALUE),
                    /* MSG_INTL(MSG_A2_DESC_SI_FLAGS) */
                    ELFEDIT_I18NHDL(MSG_A2_DESC_SI_FLAGS),
                    ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT },
                { NULL }
        };

        static elfedit_cmd_t cmds[] = {
                /* sym:dump */
                { cmd_dump, NULL, name_dump,
                    /* MSG_INTL(MSG_DESC_DUMP) */
                    ELFEDIT_I18NHDL(MSG_DESC_DUMP),
                    /* MSG_INTL(MSG_HELP_DUMP) */
                    ELFEDIT_I18NHDL(MSG_HELP_DUMP),
                    opt_dump, arg_dump },

                /* sym:si_boundto */
                { cmd_si_boundto, cpl_si_boundto, name_si_boundto,
                    /* MSG_INTL(MSG_DESC_SI_BOUNDTO) */
                    ELFEDIT_I18NHDL(MSG_DESC_SI_BOUNDTO),
                    /* MSG_INTL(MSG_HELP_SI_BOUNDTO) */
                    ELFEDIT_I18NHDL(MSG_HELP_SI_BOUNDTO),
                    opt_si_boundto, arg_si_boundto },

                /* sym:si_flags */
                { cmd_si_flags, cpl_si_flags, name_si_flags,
                    /* MSG_INTL(MSG_DESC_SI_FLAGS) */
                    ELFEDIT_I18NHDL(MSG_DESC_SI_FLAGS),
                    /* MSG_INTL(MSG_HELP_SI_FLAGS) */
                    ELFEDIT_I18NHDL(MSG_HELP_SI_FLAGS),
                    opt_si_flags, arg_si_flags },

                { NULL }
        };

        static elfedit_module_t module = {
            ELFEDIT_VER_CURRENT, MSG_ORIG(MSG_MOD_NAME),
            /* MSG_INTL(MSG_MOD_DESC) */
            ELFEDIT_I18NHDL(MSG_MOD_DESC),
            cmds, mod_i18nhdl_to_str };

        return (&module);
}