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


/*
 * Program headers
 */



/*
 * This module uses shared code for several of the commands.
 * It is sometimes necessary to know which specific command
 * is active.
 */
typedef enum {
        /* Dump command, used as module default to display dynamic section */
        PHDR_CMD_T_DUMP =       0,      /* phdr:dump */

        /* Commands that correspond directly to program header fields */
        PHDR_CMD_T_P_TYPE =     1,      /* phdr:p_type */
        PHDR_CMD_T_P_OFFSET =   2,      /* phdr:p_offset */
        PHDR_CMD_T_P_VADDR =    3,      /* phdr:p_vaddr */
        PHDR_CMD_T_P_PADDR =    4,      /* phdr:p_paddr */
        PHDR_CMD_T_P_FILESZ =   5,      /* phdr:p_filesz */
        PHDR_CMD_T_P_MEMSZ =    6,      /* phdr:p_memsz */
        PHDR_CMD_T_P_FLAGS =    7,      /* phdr:p_flags */
        PHDR_CMD_T_P_ALIGN =    8,      /* phdr:p_align */

        /* Commands that do not correspond directly to a specific phdr tag */
        PHDR_CMD_T_INTERP =     9,      /* phdr:interp */
        PHDR_CMD_T_DELETE =     10,     /* phdr:delete */
        PHDR_CMD_T_MOVE =       11      /* phdr:move */
} PHDR_CMD_T;



/*
 * The following type is ued by locate_interp() to return
 * information about the interpreter program header.
 */
typedef struct {
        Word                    phndx;  /* Index of PT_INTERP header */
        Phdr                    *phdr;          /* PT_INTERP header */
        elfedit_section_t       *sec;           /* Section containing string */
        Word                    stroff;         /* Offset into string section */
        const char              *str;           /* Interpreter string */
} INTERP_STATE;


#ifndef _ELF64
/*
 * We supply this function for the msg module
 */
const char *
_phdr_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 phdr_opt_t enum specifies a bit value for every optional
 * argument allowed by a command in this module.
 */
typedef enum {
        PHDR_OPT_F_AND =        1,      /* -and: AND (&) values to dest */
        PHDR_OPT_F_CMP =        2,      /* -cmp: Complement (~) values */
        PHDR_OPT_F_PHNDX =      4,      /* -phndx: Program header by index, */
                                        /*      not by name */
        PHDR_OPT_F_OR =         8       /* -or: OR (|) values to dest */
} phdr_opt_t;


/*
 * A variable of type ARGSTATE is used by each command to maintain
 * information about the section headers and related things. It is
 * initialized by process_args(), and used by the other routines.
 */
typedef struct {
        elfedit_obj_state_t     *obj_state;
        phdr_opt_t              optmask;        /* Mask of options used */
        int                     argc;           /* # of plain arguments */
        const char              **argv;         /* Plain arguments */
        int                     ndx_set;        /* True if ndx is valid */
        Word                    ndx;            /* Index of header if cmd */
                                                /*      accepts it */
        int                     print_req;      /* Call is a print request */
} ARGSTATE;


/*
 * Standard argument processing for phdr module
 *
 * entry
 *      obj_state, argc, argv - Standard command arguments
 *      optmask - Mask of allowed optional arguments.
 *      cmd - PHDR_CMD_T_* value giving identify of caller
 *      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.
 */
static void
process_args(elfedit_obj_state_t *obj_state, int argc, const char *argv[],
    PHDR_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;

        /* Are the right number of plain arguments present? */
        switch (cmd) {
        case PHDR_CMD_T_DUMP:
                if (argc > 1)
                        elfedit_command_usage();
                argstate->print_req = 1;
                break;
        case PHDR_CMD_T_P_FLAGS:
                /* phdr:sh_flags allows an arbitrary number of arguments */
                argstate->print_req = (argc < 2);
                break;
        case PHDR_CMD_T_INTERP:
                if (argc > 1)
                        elfedit_command_usage();
                argstate->print_req = (argc == 0);
                break;
        case PHDR_CMD_T_DELETE:
                if ((argc < 1) || (argc > 2))
                        elfedit_command_usage();
                argstate->print_req = 0;
                break;
        case PHDR_CMD_T_MOVE:
                if ((argc < 2) || (argc > 3))
                        elfedit_command_usage();
                argstate->print_req = 0;
                break;

        default:
                /* The remaining commands accept 2 plain arguments */
                if (argc > 2)
                        elfedit_command_usage();
                argstate->print_req = (argc < 2);
                break;
        }

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

        argstate->ndx_set = 0;
        if ((argc > 0) && (cmd != PHDR_CMD_T_INTERP)) {
                /*
                 * If the -phndx option is present, the first argument is
                 * the index of the header to use. Otherwise, it is a
                 * name corresponding to its type, similar to the way
                 * elfdump works with its -N option.
                 */
                if (argstate->optmask & PHDR_OPT_F_PHNDX) {
                        argstate->ndx = (Word) elfedit_atoui_range(
                            argstate->argv[0], MSG_ORIG(MSG_STR_ELEMENT), 0,
                            argstate->obj_state->os_phnum - 1, NULL);
                        argstate->ndx_set = 1;
                } else {
                        Conv_inv_buf_t inv_buf;
                        Ehdr            *ehdr = obj_state->os_ehdr;
                        Half            mach = ehdr->e_machine;
                        uchar_t         osabi = ehdr->e_ident[EI_OSABI];
                        Word            i;
                        Phdr            *phdr;

                        argstate->ndx = (Word) elfedit_atoconst(
                            argstate->argv[0], ELFEDIT_CONST_PT);
                        phdr = obj_state->os_phdr;
                        for (i = 0; i < obj_state->os_phnum; i++, phdr++) {
                                if (phdr->p_type == argstate->ndx) {
                                        argstate->ndx = i;
                                        argstate->ndx_set = 1;
                                        elfedit_msg(ELFEDIT_MSG_DEBUG,
                                            MSG_INTL(MSG_DEBUG_PHDR),
                                            EC_WORD(i), conv_phdr_type(osabi,
                                            mach, phdr->p_type, 0, &inv_buf));
                                        break;
                                }
                        }
                        if (i == argstate->obj_state->os_phnum)
                                elfedit_msg(ELFEDIT_MSG_ERR,
                                    MSG_INTL(MSG_ERR_NOPHDR), conv_phdr_type(
                                    osabi, mach, argstate->ndx, 0, &inv_buf));
                }
        }

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

}



/*
 * Locate the interpreter string for the object and related information
 *
 * entry:
 *      obj_state - Object state
 *      interp - NULL, or variable to be filled in with information
 *              about the interpteter string.
 */
static const char *
locate_interp(elfedit_obj_state_t *obj_state, INTERP_STATE *interp)
{
        INTERP_STATE            local_interp;
        elfedit_section_t       *strsec;        /* String table */
        size_t          phnum;          /* # of program headers */
        int             phndx;          /* Index of PT_INTERP program header */
        Phdr            *phdr;          /* Program header array */
        Word            i;

        if (interp == NULL)
                interp = &local_interp;

        /* Locate the PT_INTERP program header */
        phnum = obj_state->os_phnum;
        phdr = obj_state->os_phdr;

        for (phndx = 0; phndx < phnum; phndx++) {
                if (phdr[phndx].p_type  == PT_INTERP) {
                        interp->phndx = phndx;
                        interp->phdr = phdr + phndx;
                        break;
                }
        }
        /* If no PT_INTERP program header found, we cannot proceed */
        if (phndx == phnum)
                elfedit_elferr(obj_state->os_file,
                    MSG_INTL(MSG_ERR_NOINTERPPHDR));

        /*
         * Locate the section containing the interpteter string as well
         * as the string itself.
         *
         * The program header contains a direct offset to the string, so
         * we find the section by walking through the them looking for
         * the one with a base and size that would contain the string.
         * Note that this target section cannot be in a NOBITS section.
         */
        for (i = 1; i < obj_state->os_shnum; i++) {
                strsec = &obj_state->os_secarr[i];

                if ((strsec->sec_shdr->sh_type != SHT_NOBITS) &&
                    (interp->phdr->p_offset >= strsec->sec_shdr->sh_offset) &&
                    ((interp->phdr->p_offset + interp->phdr->p_filesz) <=
                    (strsec->sec_shdr->sh_offset +
                    strsec->sec_shdr->sh_size))) {
                        interp->sec = strsec;

                        interp->stroff = interp->phdr->p_offset -
                            strsec->sec_shdr->sh_offset;
                        interp->str = ((char *)strsec->sec_data->d_buf) +
                            interp->stroff;
                        return (interp->str);
                }
        }

        /*
         * We don't expect to get here: If there is a PT_INTERP header,
         * we fully expect the string to exist.
         */
        elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_NOINTERPSEC));
        /*NOTREACHED*/

        return (NULL);          /* For lint */
}

/*
 * Print program header values, taking the calling command, and output style
 * into account.
 *
 * entry:
 *      autoprint - If True, output is only produced if the elfedit
 *              autoprint flag is set. If False, output is always produced.
 *      cmd - PHDR_CMD_T_* value giving identify of caller
 *      argstate - State block for section header array. The following
 *              fields are examined in order to determine the form
 *              of output: ndx_set, ndx, print_req.
 */
static void
print_phdr(PHDR_CMD_T cmd, int autoprint, ARGSTATE *argstate)
{
        elfedit_outstyle_t      outstyle;
        Ehdr                    *ehdr = argstate->obj_state->os_ehdr;
        uchar_t                 osabi = ehdr->e_ident[EI_OSABI];
        Half                    mach = ehdr->e_machine;
        Word                    ndx, cnt, by_type, type;
        Phdr                    *phdr;

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

        /*
         * Determine which indexes to display:
         *
         * -    If the user specified an index, the display starts
         *      with that item. If it was a print_request, and the
         *      index was specified by type, then all items of the
         *      same type are shown. If not a print request, or the index
         *      was given numerically, then just the single item is shown.
         *
         * -    If no index is specified, every program header is shown.
         */
        by_type = 0;
        if (argstate->ndx_set) {
                ndx = argstate->ndx;
                if (argstate->print_req &&
                    ((argstate->optmask & PHDR_OPT_F_PHNDX) == 0)) {
                        by_type = 1;
                        type = argstate->obj_state->os_phdr[ndx].p_type;
                        cnt = argstate->obj_state->os_phnum - ndx;
                } else {
                        cnt = 1;
                }
        } else {
                ndx = 0;
                cnt = argstate->obj_state->os_phnum;
        }
        phdr = argstate->obj_state->os_phdr + ndx;

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

        /*
         * If doing default output, use elfdump style where we
         * show all program header attributes. In this case, the
         * command that called us doesn't matter.
         *
         * Exclude PHDR_CMD_T_INTERP from this: It isn't per-phdr like
         * the other commands.
         */
        if ((outstyle == ELFEDIT_OUTSTYLE_DEFAULT) &&
            (cmd != PHDR_CMD_T_INTERP)) {
                for (; cnt--; ndx++, phdr++) {
                        if (by_type && (type != phdr->p_type))
                                continue;

                        elfedit_printf(MSG_ORIG(MSG_STR_NL));
                        elfedit_printf(MSG_INTL(MSG_ELF_PHDR), EC_WORD(ndx));
                        Elf_phdr(0, osabi, mach, phdr);
                }
                return;
        }

        if (cmd == PHDR_CMD_T_INTERP) {
                INTERP_STATE interp;

                (void) locate_interp(argstate->obj_state, &interp);
                switch (outstyle) {
                case ELFEDIT_OUTSTYLE_DEFAULT:
                        elfedit_printf(MSG_INTL(MSG_FMT_ELF_INTERP),
                            interp.sec->sec_name, interp.str);
                        break;
                case ELFEDIT_OUTSTYLE_SIMPLE:
                        elfedit_printf(MSG_ORIG(MSG_FMT_STRNL), interp.str);
                        break;
                case ELFEDIT_OUTSTYLE_NUM:
                        elfedit_printf(MSG_ORIG(MSG_FMT_U_NL),
                            EC_WORD(interp.stroff));
                        break;
                }
                return;
        }

        /* Handle the remaining commands */
        for (; cnt--; ndx++, phdr++) {
                if (by_type && (type != phdr->p_type))
                        continue;

                switch (cmd) {
                case PHDR_CMD_T_P_TYPE:
                        if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
                                Conv_inv_buf_t inv_buf;

                                elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
                                    conv_phdr_type(osabi,
                                    argstate->obj_state->os_ehdr->e_machine,
                                    phdr->p_type, 0, &inv_buf));
                        } else {
                                elfedit_printf(MSG_ORIG(MSG_FMT_X_NL),
                                    EC_WORD(phdr->p_type));
                        }
                        break;

                case PHDR_CMD_T_P_OFFSET:
                        elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL),
                            EC_OFF(phdr->p_offset));
                        break;

                case PHDR_CMD_T_P_VADDR:
                        elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL),
                            EC_ADDR(phdr->p_vaddr));
                        break;

                case PHDR_CMD_T_P_PADDR:
                        elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL),
                            EC_ADDR(phdr->p_paddr));
                        break;

                case PHDR_CMD_T_P_FILESZ:
                        elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL),
                            EC_XWORD(phdr->p_filesz));
                        break;

                case PHDR_CMD_T_P_MEMSZ:
                        elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL),
                            EC_XWORD(phdr->p_memsz));
                        break;

                case PHDR_CMD_T_P_FLAGS:
                        if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
                                Conv_phdr_flags_buf_t phdr_flags_buf;

                                elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
                                    conv_phdr_flags(osabi, phdr->p_flags,
                                    CONV_FMT_NOBKT, &phdr_flags_buf));
                        } else {
                                elfedit_printf(MSG_ORIG(MSG_FMT_X_NL),
                                    EC_WORD(phdr->p_flags));
                        }
                        break;

                case PHDR_CMD_T_P_ALIGN:
                        elfedit_printf(MSG_ORIG(MSG_FMT_LLX_NL),
                            EC_XWORD(phdr->p_align));
                        break;
                }
        }
}


/*
 * Called from cmd_body() in the case where a plain argument
 * is given to phdr:interp to change the interpreter.
 */
static elfedit_cmdret_t
cmd_body_set_interp(ARGSTATE *argstate)
{
        elfedit_obj_state_t     *obj_state = argstate->obj_state;
        elfedit_section_t       *strsec;        /* String table */
        INTERP_STATE    interp;
        Word            numdyn;         /* # of elements in dyn arr */
        size_t          phnum;          /* # of program headers */
        Phdr            *phdr;          /* Program header array */
        Word            i, j;
        Word            str_offset;     /* Offset in strsec to new interp str */
        int             str_found = 0;   /* True when we have new interp str */
        Word            str_size;       /* Size of new interp string + NULL */

        phnum = obj_state->os_phnum;
        phdr = obj_state->os_phdr;

        /* Locate the PT_INTERP program header */
        (void) locate_interp(obj_state, &interp);
        strsec = interp.sec;
        str_offset = interp.stroff;

        /*
         * If the given string is the same as the existing interpreter
         * string, say so and return.
         */
        if (strcmp(interp.str, argstate->argv[0]) == 0) {
                elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_OLDINTERPOK),
                    EC_WORD(strsec->sec_shndx), strsec->sec_name,
                    EC_WORD(str_offset), interp.str);
                return (ELFEDIT_CMDRET_NONE);
        }

        /*
         * An ELF PT_INTERP usually references its own special section
         * instead of some other string table. The ELF ABI says that this
         * section must be named ".interp". Hence, this is a rare case
         * in which the name of a section can be taken as an indication
         * of its contents. .interp is typically sized to just fit
         * the original string, including its NULL termination. You can
         * treat it as a string table with one string.
         *
         * Thanks to 'elfedit', it may be that we encounter a file where
         * PT_INTERP does not reference the .interp section. This will happen
         * if elfedit is used to change the interpreter to a string that is
         * too big to fit in .interp, in which case we will use the
         * .dynstr string table (That code is below, in this function).
         *
         * Given the above facts, our next step is to locate the .interp
         * section and see if our new string will fit in it. Since we can't
         * depend on PT_INTERP, we search the section headers to find a
         * section whith the following characteristics:
         *      - The name is ".interp".
         *      - Section is allocable (SHF_ALLOC) and SHT_PROGBITS.
         *      - It is not part of a writable segment.
         * If we find such a section, and the new string fits, we will
         * write it there.
         */
        str_size = strlen(argstate->argv[0]) + 1;
        for (i = 1; i < obj_state->os_shnum; i++) {
                strsec = &obj_state->os_secarr[i];
                if ((strcmp(strsec->sec_name, MSG_ORIG(MSG_SEC_INTERP)) == 0) &&
                    (strsec->sec_shdr->sh_flags & SHF_ALLOC) &&
                    (strsec->sec_shdr->sh_type & SHT_PROGBITS)) {
                        for (j = 0; j < phnum; j++) {
                                Phdr *tphdr = &phdr[j];
                                if ((strsec->sec_shdr->sh_offset >=
                                    tphdr->p_offset) &&
                                    ((strsec->sec_shdr->sh_offset +
                                    strsec->sec_shdr->sh_size) <=
                                    (tphdr->p_offset + tphdr->p_filesz)) &&
                                    (tphdr->p_flags & PF_W)) {
                                        break;
                                }
                        }
                        if ((j == phnum) &&
                            (str_size <= strsec->sec_shdr->sh_size)) {
                                /* .interp section found, and has room */
                                str_found = 1;
                                str_offset = 0;
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_NEWISTR), EC_WORD(j),
                                    strsec->sec_name, EC_WORD(str_offset),
                                    argstate->argv[0]);
                                /* Put new value in section */
                                (void) strncpy((char *)strsec->sec_data->d_buf,
                                    argstate->argv[0],
                                    strsec->sec_shdr->sh_size);
                                /* Set libelf dirty bit so change is flushed */
                                elfedit_modified_data(strsec);
                                break;
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LNGISTR), EC_WORD(j),
                                    strsec->sec_name, EC_WORD(str_offset),
                                    EC_WORD(str_size),
                                    EC_WORD(strsec->sec_shdr->sh_size),
                                    argstate->argv[0]);
                        }
                }
        }

        /*
         * If the above did not find a string within the .interp section,
         * then we have a second option. If this ELF object has a dynamic
         * section, then we are willing to use strings from within the
         * associated .dynstr string table. And if there is reserved space
         * in .dynstr (as reported by the DT_SUNW_STRPAD dynamic entry),
         * then we are even willing to add a new string to .dynstr.
         */
        if (!str_found) {
                elfedit_section_t       *dynsec;
                Dyn                     *dyn;

                dynsec = elfedit_sec_getdyn(obj_state, &dyn, &numdyn);
                strsec = elfedit_sec_getstr(obj_state,
                    dynsec->sec_shdr->sh_link, 0);

                /* Does string exist in the table already, or can we add it? */
                str_offset = elfedit_strtab_insert(obj_state, strsec,
                    dynsec, argstate->argv[0]);
        }


        /*
         * If we are here, we know we have a replacement string, because
         * the errors from checking .dynamic/.dynstr will not allow
         * things to get here otherwise.
         *
         * The PT_INTERP program header references the string directly,
         * so we add the section offset to the string offset.
         */
        interp.phdr->p_offset = strsec->sec_shdr->sh_offset + str_offset;
        interp.phdr->p_filesz = str_size;
        elfedit_modified_phdr(obj_state);
        elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_SETPHINTERP),
            EC_WORD(interp.phndx), EC_XWORD(interp.phdr->p_offset),
            EC_XWORD(interp.phdr->p_filesz));

        return (ELFEDIT_CMDRET_MOD);
}


/*
 * Common body for the phdr: 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 PHDR_CMD_T_* constants listed above, specifying
 *              which command to implement.
 *      obj_state, argc, argv - Standard command arguments
 */
static elfedit_cmdret_t
cmd_body(PHDR_CMD_T cmd, elfedit_obj_state_t *obj_state,
    int argc, const char *argv[])
{
        ARGSTATE                argstate;
        Phdr                    *phdr;
        elfedit_cmdret_t        ret = ELFEDIT_CMDRET_NONE;
        int                     do_autoprint = 1;

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

        /* If this is a printing request, print and return */
        if (argstate.print_req) {
                print_phdr(cmd, 0, &argstate);
                return (ELFEDIT_CMDRET_NONE);
        }


        if (argstate.ndx_set)
                phdr = &argstate.obj_state->os_phdr[argstate.ndx];

        switch (cmd) {
                /*
                 * PHDR_CMD_T_DUMP can't get here: It never has more than
                 * one argument, and is handled above.
                 */

        case PHDR_CMD_T_P_TYPE:
                {
                        Ehdr    *ehdr = obj_state->os_ehdr;
                        uchar_t osabi = ehdr->e_ident[EI_OSABI];
                        Half    mach = ehdr->e_machine;
                        Word p_type = elfedit_atoconst(argstate.argv[1],
                            ELFEDIT_CONST_PT);
                        Conv_inv_buf_t inv_buf1, inv_buf2;

                        if (phdr->p_type == p_type) {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_S_OK),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_TYPE),
                                    conv_phdr_type(osabi, mach, phdr->p_type,
                                    0, &inv_buf1));
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_S_CHG),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_TYPE),
                                    conv_phdr_type(osabi, mach,
                                    phdr->p_type, 0, &inv_buf1),
                                    conv_phdr_type(osabi, mach,
                                    p_type, 0, &inv_buf2));
                                ret = ELFEDIT_CMDRET_MOD;
                                phdr->p_type = p_type;
                        }
                }
                break;

        case PHDR_CMD_T_P_OFFSET:
                {
                        Off p_offset;

                        p_offset = elfedit_atoui(argstate.argv[1], NULL);
                        if (phdr->p_offset == p_offset) {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_OK),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_OFFSET),
                                    EC_XWORD(phdr->p_offset));
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_CHG),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_OFFSET),
                                    EC_XWORD(phdr->p_offset),
                                    EC_XWORD(p_offset));
                                ret = ELFEDIT_CMDRET_MOD;
                                phdr->p_offset = p_offset;
                        }
                }
                break;

        case PHDR_CMD_T_P_VADDR:
                {
                        Addr p_vaddr = elfedit_atoui(argstate.argv[1], NULL);

                        if (phdr->p_vaddr == p_vaddr) {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_OK),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_VADDR),
                                    EC_ADDR(phdr->p_vaddr));
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_CHG),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_VADDR),
                                    EC_ADDR(phdr->p_vaddr), EC_ADDR(p_vaddr));
                                ret = ELFEDIT_CMDRET_MOD;
                                phdr->p_vaddr = p_vaddr;
                        }
                }
                break;

        case PHDR_CMD_T_P_PADDR:
                {
                        Addr p_paddr = elfedit_atoui(argstate.argv[1], NULL);

                        if (phdr->p_paddr == p_paddr) {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_OK),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_PADDR),
                                    EC_ADDR(phdr->p_paddr));
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_CHG),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_PADDR),
                                    EC_ADDR(phdr->p_paddr), EC_ADDR(p_paddr));
                                ret = ELFEDIT_CMDRET_MOD;
                                phdr->p_paddr = p_paddr;
                        }
                }
                break;

        case PHDR_CMD_T_P_FILESZ:
                {
                        Xword p_filesz = elfedit_atoui(argstate.argv[1], NULL);

                        if (phdr->p_filesz == p_filesz) {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_OK),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_FILESZ),
                                    EC_XWORD(phdr->p_filesz));
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_CHG),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_FILESZ),
                                    EC_XWORD(phdr->p_filesz),
                                    EC_XWORD(p_filesz));
                                ret = ELFEDIT_CMDRET_MOD;
                                phdr->p_filesz = p_filesz;
                        }
                }
                break;

        case PHDR_CMD_T_P_MEMSZ:
                {
                        Xword p_memsz = elfedit_atoui(argstate.argv[1], NULL);

                        if (phdr->p_memsz == p_memsz) {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_OK),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_MEMSZ),
                                    EC_XWORD(phdr->p_memsz));
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_CHG),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_MEMSZ),
                                    EC_XWORD(phdr->p_memsz),
                                    EC_XWORD(p_memsz));
                                ret = ELFEDIT_CMDRET_MOD;
                                phdr->p_memsz = p_memsz;
                        }
                }
                break;

        case PHDR_CMD_T_P_FLAGS:
                {
                        Ehdr    *ehdr = obj_state->os_ehdr;
                        uchar_t osabi = ehdr->e_ident[EI_OSABI];
                        Conv_phdr_flags_buf_t buf1, buf2;
                        Word    p_flags = 0;
                        int     i;

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

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

                        /* Perform any requested bit operations */
                        if (argstate.optmask & PHDR_OPT_F_AND)
                                p_flags &= phdr->p_flags;
                        else if (argstate.optmask & PHDR_OPT_F_OR)
                                p_flags |= phdr->p_flags;

                        /* Set the value */
                        if (phdr->p_flags == p_flags) {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_S_OK),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_FLAGS),
                                    conv_phdr_flags(osabi, phdr->p_flags,
                                    0, &buf1));
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_S_CHG),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_FLAGS),
                                    conv_phdr_flags(osabi, phdr->p_flags,
                                    0, &buf1),
                                    conv_phdr_flags(osabi, p_flags, 0, &buf2));
                                ret = ELFEDIT_CMDRET_MOD;
                                phdr->p_flags = p_flags;
                        }
                }
                break;

        case PHDR_CMD_T_P_ALIGN:
                {
                        Xword p_align = elfedit_atoui(argstate.argv[1], NULL);

                        if (phdr->p_align == p_align) {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_OK),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_ALIGN),
                                    EC_XWORD(phdr->p_align));
                        } else {
                                elfedit_msg(ELFEDIT_MSG_DEBUG,
                                    MSG_INTL(MSG_DEBUG_LLX_CHG),
                                    argstate.ndx, MSG_ORIG(MSG_CMD_P_ALIGN),
                                    EC_XWORD(phdr->p_align),
                                    EC_XWORD(p_align));
                                ret = ELFEDIT_CMDRET_MOD;
                                phdr->p_align = p_align;
                        }
                }
                break;

        case PHDR_CMD_T_INTERP:
                ret = cmd_body_set_interp(&argstate);
                break;

        case PHDR_CMD_T_DELETE:
                {
                        Word cnt = (argstate.argc == 1) ? 1 :
                            (Word) elfedit_atoui_range(argstate.argv[1],
                            MSG_ORIG(MSG_STR_COUNT), 1,
                            obj_state->os_phnum - argstate.ndx, NULL);

                        elfedit_array_elts_delete(MSG_ORIG(MSG_MOD_NAME),
                            obj_state->os_phdr, sizeof (Phdr),
                            obj_state->os_phnum, argstate.ndx, cnt);
                        do_autoprint = 0;
                        ret = ELFEDIT_CMDRET_MOD;
                }
                break;

        case PHDR_CMD_T_MOVE:
                {
                        Phdr    save;
                        Word    cnt;
                        Word    dstndx;

                        do_autoprint = 0;
                        dstndx = (Word)
                            elfedit_atoui_range(argstate.argv[1],
                            MSG_ORIG(MSG_STR_DST_INDEX), 0,
                            obj_state->os_phnum - 1, NULL);
                        if (argstate.argc == 2) {
                                cnt = 1;
                        } else {
                                cnt = (Word) elfedit_atoui_range(
                                    argstate.argv[2], MSG_ORIG(MSG_STR_COUNT),
                                    1, obj_state->os_phnum, NULL);
                        }
                        elfedit_array_elts_move(MSG_ORIG(MSG_MOD_NAME),
                            obj_state->os_phdr, sizeof (save),
                            obj_state->os_phnum, argstate.ndx, dstndx,
                            cnt, &save);
                        ret = ELFEDIT_CMDRET_MOD;
                }
                break;
        }

        /*
         * If we modified the section header array, tell libelf.
         */
        if (ret == ELFEDIT_CMDRET_MOD)
                elfedit_modified_phdr(obj_state);

        /* Do autoprint */
        if (do_autoprint)
                print_phdr(cmd, 1, &argstate);

        return (ret);
}



/*
 * Command completion functions for the various commands
 */

/*
 * A number of the commands accept a PT_ constant as their first
 * argument as long as the -phndx option is not used.
 */
/*ARGSUSED*/
static void
cpl_1starg_pt(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
    const char *argv[], int num_opt)
{
        int i;

        for (i = 0; i < num_opt; i++)
                if (strcmp(MSG_ORIG(MSG_STR_MINUS_PHNDX), argv[i]) == 0)
                        return;

        if (argc == (num_opt + 1))
                elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_PT);
}

/*ARGSUSED*/
static void
cpl_p_type(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
    const char *argv[], int num_opt)
{
        /* The first argument follows the standard rules */
        cpl_1starg_pt(obj_state, cpldata, argc, argv, num_opt);

        /* The second argument can be a PT_ value */
        if (argc == (num_opt + 2))
                elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_PT);
}


/*ARGSUSED*/
static void
cpl_p_flags(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
    const char *argv[], int num_opt)
{
        /* The first argument follows the standard rules */
        cpl_1starg_pt(obj_state, cpldata, argc, argv, num_opt);

        /* The second and following arguments can be an PF_ value */
        if (argc >= (num_opt + 2))
                elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_PF);
}



/*
 * 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(PHDR_CMD_T_DUMP, obj_state, argc, argv));
}

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

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

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

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

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

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

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

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

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

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

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


/*ARGSUSED*/
elfedit_module_t *
elfedit_init(elfedit_module_version_t version)
{
        /* Multiple commands accept a standard set of options */
        static elfedit_cmd_optarg_t opt_std[] = {
                { ELFEDIT_STDOA_OPT_O, 0,
                    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
                { MSG_ORIG(MSG_STR_MINUS_PHNDX),
                    /* MSG_INTL(MSG_OPTDESC_PHNDX) */
                    ELFEDIT_I18NHDL(MSG_OPTDESC_PHNDX), 0,
                    PHDR_OPT_F_PHNDX, 0 },
                { NULL }
        };

        /* For commands that only accept -phndx */
        static elfedit_cmd_optarg_t opt_minus_phndx[] = {
                { MSG_ORIG(MSG_STR_MINUS_PHNDX),
                    /* MSG_INTL(MSG_OPTDESC_PHNDX) */
                    ELFEDIT_I18NHDL(MSG_OPTDESC_PHNDX), 0,
                    PHDR_OPT_F_PHNDX, 0 },
                { NULL }
        };


        /* phdr: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 arg_dump[] = {
                { MSG_ORIG(MSG_STR_ELEMENT),
                    /* MSG_INTL(MSG_A1_ELEMENT) */
                    ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* phdr:p_type */
        static const char *name_p_type[] = { MSG_ORIG(MSG_CMD_P_TYPE), NULL };
        static elfedit_cmd_optarg_t arg_p_type[] = {
                { MSG_ORIG(MSG_STR_ELEMENT),
                    /* MSG_INTL(MSG_A1_ELEMENT) */
                    ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_TYPE),
                    /* MSG_INTL(MSG_A2_P_TYPE_TYPE) */
                    ELFEDIT_I18NHDL(MSG_A2_P_TYPE_TYPE),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* phdr:p_offset */
        static const char *name_p_offset[] = { MSG_ORIG(MSG_CMD_P_OFFSET),
            NULL };
        static elfedit_cmd_optarg_t arg_p_offset[] = {
                { MSG_ORIG(MSG_STR_ELEMENT),
                    /* MSG_INTL(MSG_A1_ELEMENT) */
                    ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_VALUE),
                    /* MSG_INTL(MSG_A2_P_OFFSET_VALUE) */
                    ELFEDIT_I18NHDL(MSG_A2_P_OFFSET_VALUE),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* phdr:p_vaddr */
        static const char *name_p_vaddr[] = { MSG_ORIG(MSG_CMD_P_VADDR),
            NULL };
        static elfedit_cmd_optarg_t arg_p_vaddr[] = {
                { MSG_ORIG(MSG_STR_ELEMENT),
                    /* MSG_INTL(MSG_A1_ELEMENT) */
                    ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_ADDR),
                    /* MSG_INTL(MSG_A2_P_VADDR_ADDR) */
                    ELFEDIT_I18NHDL(MSG_A2_P_VADDR_ADDR),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* phdr:p_paddr */
        static const char *name_p_paddr[] = { MSG_ORIG(MSG_CMD_P_PADDR),
            NULL };
        static elfedit_cmd_optarg_t arg_p_paddr[] = {
                { MSG_ORIG(MSG_STR_ELEMENT),
                    /* MSG_INTL(MSG_A1_ELEMENT) */
                    ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_ADDR),
                    /* MSG_INTL(MSG_A2_P_PADDR_ADDR) */
                    ELFEDIT_I18NHDL(MSG_A2_P_PADDR_ADDR),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* phdr:p_filesz */
        static const char *name_p_filesz[] = { MSG_ORIG(MSG_CMD_P_FILESZ),
            NULL };
        static elfedit_cmd_optarg_t arg_p_filesz[] = {
            /* MSG_INTL(MSG_A1_ELEMENT) */
                { MSG_ORIG(MSG_STR_ELEMENT), ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_SIZE),
                    /* MSG_INTL(MSG_A2_P_FILESZ_SIZE) */
                    ELFEDIT_I18NHDL(MSG_A2_P_FILESZ_SIZE),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* phdr:p_memsz */
        static const char *name_p_memsz[] = { MSG_ORIG(MSG_CMD_P_MEMSZ),
            NULL };
        static elfedit_cmd_optarg_t arg_p_memsz[] = {
                { MSG_ORIG(MSG_STR_ELEMENT),
                    /* MSG_INTL(MSG_A1_ELEMENT) */
                    ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_SIZE),
                    /* MSG_INTL(MSG_A2_P_MEMSZ_SIZE) */
                    ELFEDIT_I18NHDL(MSG_A2_P_MEMSZ_SIZE),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* shdr:p_flags */
        static const char *name_p_flags[] = {
            MSG_ORIG(MSG_CMD_P_FLAGS), NULL };
        static elfedit_cmd_optarg_t opt_p_flags[] = {
                { ELFEDIT_STDOA_OPT_AND, 0,
                    ELFEDIT_CMDOA_F_INHERIT, PHDR_OPT_F_AND, PHDR_OPT_F_OR },
                { ELFEDIT_STDOA_OPT_CMP, 0,
                    ELFEDIT_CMDOA_F_INHERIT, PHDR_OPT_F_CMP, 0 },
                { MSG_ORIG(MSG_STR_MINUS_PHNDX),
                    /* MSG_INTL(MSG_OPTDESC_PHNDX) */
                    ELFEDIT_I18NHDL(MSG_OPTDESC_PHNDX), 0,
                    PHDR_OPT_F_PHNDX, 0 },
                { ELFEDIT_STDOA_OPT_O, 0,
                    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
                { ELFEDIT_STDOA_OPT_OR, 0,
                    ELFEDIT_CMDOA_F_INHERIT, PHDR_OPT_F_OR, PHDR_OPT_F_AND },
                { NULL }
        };
        static elfedit_cmd_optarg_t arg_p_flags[] = {
                { MSG_ORIG(MSG_STR_ELEMENT),
                    /* MSG_INTL(MSG_A1_ELEMENT) */
                    ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_VALUE),
                    /* MSG_INTL(MSG_A2_P_FLAGS_VALUE) */
                    ELFEDIT_I18NHDL(MSG_A2_P_FLAGS_VALUE),
                    ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT },
                { NULL }
        };

        /* phdr:p_align */
        static const char *name_p_align[] = { MSG_ORIG(MSG_CMD_P_ALIGN),
            NULL };
        static elfedit_cmd_optarg_t arg_p_align[] = {
                { MSG_ORIG(MSG_STR_ELEMENT),
                    /* MSG_INTL(MSG_A1_ELEMENT) */
                    ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_ALIGN),
                    /* MSG_INTL(MSG_A2_P_ALIGN_ALIGN) */
                    ELFEDIT_I18NHDL(MSG_A2_P_ALIGN_ALIGN),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* phdr:interp */
        static const char *name_interp[] = { MSG_ORIG(MSG_CMD_INTERP), NULL };
        static elfedit_cmd_optarg_t opt_interp[] = {
                { ELFEDIT_STDOA_OPT_O, 0,
                    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
                { NULL }
        };
        static elfedit_cmd_optarg_t arg_interp[] = {
                { MSG_ORIG(MSG_STR_NEWPATH),
                    /* MSG_INTL(MSG_A1_INTERP_NEWPATH) */
                    ELFEDIT_I18NHDL(MSG_A1_INTERP_NEWPATH),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* phdr:delete */
        static const char *name_delete[] = { MSG_ORIG(MSG_CMD_DELETE), NULL };
        static elfedit_cmd_optarg_t arg_delete[] = {
                { MSG_ORIG(MSG_STR_ELEMENT),
                    /* MSG_INTL(MSG_A1_ELEMENT) */
                    ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    0 },
                { MSG_ORIG(MSG_STR_COUNT),
                    /* MSG_INTL(MSG_A2_DELETE_COUNT) */
                    ELFEDIT_I18NHDL(MSG_A2_DELETE_COUNT),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        /* phdr:move */
        static const char *name_move[] = { MSG_ORIG(MSG_CMD_MOVE), NULL };
        static elfedit_cmd_optarg_t arg_move[] = {
                { MSG_ORIG(MSG_STR_ELEMENT),
                    /* MSG_INTL(MSG_A1_ELEMENT) */
                    ELFEDIT_I18NHDL(MSG_A1_ELEMENT),
                    ELFEDIT_CMDOA_F_OPT },
                { MSG_ORIG(MSG_STR_DST_INDEX),
                    /* MSG_INTL(MSG_A2_MOVE_DST_INDEX) */
                    ELFEDIT_I18NHDL(MSG_A2_MOVE_DST_INDEX),
                    0 },
                { MSG_ORIG(MSG_STR_COUNT),
                    /* MSG_INTL(MSG_A3_MOVE_COUNT) */
                    ELFEDIT_I18NHDL(MSG_A3_MOVE_COUNT),
                    ELFEDIT_CMDOA_F_OPT },
                { NULL }
        };

        static elfedit_cmd_t cmds[] = {
                /* phdr:dump */
                { cmd_dump, cpl_1starg_pt, name_dump,
                    /* MSG_INTL(MSG_DESC_DUMP) */
                    ELFEDIT_I18NHDL(MSG_DESC_DUMP),
                    /* MSG_INTL(MSG_HELP_DUMP) */
                    ELFEDIT_I18NHDL(MSG_HELP_DUMP),
                    opt_minus_phndx, arg_dump },

                /* phdr:p_type */
                { cmd_p_type, cpl_p_type, name_p_type,
                    /* MSG_INTL(MSG_DESC_P_TYPE) */
                    ELFEDIT_I18NHDL(MSG_DESC_P_TYPE),
                    /* MSG_INTL(MSG_HELP_P_TYPE) */
                    ELFEDIT_I18NHDL(MSG_HELP_P_TYPE),
                    opt_std, arg_p_type },

                /* phdr:p_offset */
                { cmd_p_offset, cpl_1starg_pt, name_p_offset,
                    /* MSG_INTL(MSG_DESC_P_OFFSET) */
                    ELFEDIT_I18NHDL(MSG_DESC_P_OFFSET),
                    /* MSG_INTL(MSG_HELP_P_OFFSET) */
                    ELFEDIT_I18NHDL(MSG_HELP_P_OFFSET),
                    opt_std, arg_p_offset },

                /* phdr:p_vaddr */
                { cmd_p_vaddr, cpl_1starg_pt, name_p_vaddr,
                    /* MSG_INTL(MSG_DESC_P_VADDR) */
                    ELFEDIT_I18NHDL(MSG_DESC_P_VADDR),
                    /* MSG_INTL(MSG_HELP_P_VADDR) */
                    ELFEDIT_I18NHDL(MSG_HELP_P_VADDR),
                    opt_std, arg_p_vaddr },

                /* phdr:p_paddr */
                { cmd_p_paddr, cpl_1starg_pt, name_p_paddr,
                    /* MSG_INTL(MSG_DESC_P_PADDR) */
                    ELFEDIT_I18NHDL(MSG_DESC_P_PADDR),
                    /* MSG_INTL(MSG_HELP_P_PADDR) */
                    ELFEDIT_I18NHDL(MSG_HELP_P_PADDR),
                    opt_std, arg_p_paddr },

                /* phdr:p_filesz */
                { cmd_p_filesz, cpl_1starg_pt, name_p_filesz,
                    /* MSG_INTL(MSG_DESC_P_FILESZ) */
                    ELFEDIT_I18NHDL(MSG_DESC_P_FILESZ),
                    /* MSG_INTL(MSG_HELP_P_FILESZ) */
                    ELFEDIT_I18NHDL(MSG_HELP_P_FILESZ),
                    opt_std, arg_p_filesz },

                /* phdr:p_memsz */
                { cmd_p_memsz, cpl_1starg_pt, name_p_memsz,
                    /* MSG_INTL(MSG_DESC_P_MEMSZ) */
                    ELFEDIT_I18NHDL(MSG_DESC_P_MEMSZ),
                    /* MSG_INTL(MSG_HELP_P_MEMSZ) */
                    ELFEDIT_I18NHDL(MSG_HELP_P_MEMSZ),
                    opt_std, arg_p_memsz },

                /* phdr:p_flags */
                { cmd_p_flags, cpl_p_flags, name_p_flags,
                    /* MSG_INTL(MSG_DESC_P_FLAGS) */
                    ELFEDIT_I18NHDL(MSG_DESC_P_FLAGS),
                    /* MSG_INTL(MSG_HELP_P_FLAGS) */
                    ELFEDIT_I18NHDL(MSG_HELP_P_FLAGS),
                    opt_p_flags, arg_p_flags },

                /* phdr:p_align */
                { cmd_p_align, cpl_1starg_pt, name_p_align,
                    /* MSG_INTL(MSG_DESC_P_ALIGN) */
                    ELFEDIT_I18NHDL(MSG_DESC_P_ALIGN),
                    /* MSG_INTL(MSG_HELP_P_ALIGN) */
                    ELFEDIT_I18NHDL(MSG_HELP_P_ALIGN),
                    opt_std, arg_p_align },

                /* phdr:interp */
                { cmd_interp, NULL, name_interp,
                    /* MSG_INTL(MSG_DESC_INTERP) */
                    ELFEDIT_I18NHDL(MSG_DESC_INTERP),
                    /* MSG_INTL(MSG_HELP_INTERP) */
                    ELFEDIT_I18NHDL(MSG_HELP_INTERP),
                    opt_interp, arg_interp },

                /* phdr:delete */
                { cmd_delete, cpl_1starg_pt, name_delete,
                    /* MSG_INTL(MSG_DESC_DELETE) */
                    ELFEDIT_I18NHDL(MSG_DESC_DELETE),
                    /* MSG_INTL(MSG_HELP_DELETE) */
                    ELFEDIT_I18NHDL(MSG_HELP_DELETE),
                    opt_minus_phndx, arg_delete },

                /* phdr:move */
                { cmd_move, cpl_1starg_pt, name_move,
                    /* MSG_INTL(MSG_DESC_MOVE) */
                    ELFEDIT_I18NHDL(MSG_DESC_MOVE),
                    /* MSG_INTL(MSG_HELP_MOVE) */
                    ELFEDIT_I18NHDL(MSG_HELP_MOVE),
                    opt_minus_phndx, arg_move },

                { 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);
}