modules/common/shdr.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	<stdio.h>
#include	<unistd.h>
#include	<elfedit.h>
#include	<sys/elf_SPARC.h>
#include	<sys/elf_amd64.h>
#include	<strings.h>
#include	<debug.h>
#include	<conv.h>
#include	<shdr_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 {
	SHDR_CMD_T_DUMP =		0,	/* shdr:dump */

	SHDR_CMD_T_SH_ADDR =		1,	/* shdr:sh_addr */
	SHDR_CMD_T_SH_ADDRALIGN =	2,	/* shdr:sh_addralign */
	SHDR_CMD_T_SH_ENTSIZE =		3,	/* shdr:sh_entsize */
	SHDR_CMD_T_SH_FLAGS =		4,	/* shdr:sh_flags */
	SHDR_CMD_T_SH_INFO =		5,	/* shdr:sh_info */
	SHDR_CMD_T_SH_LINK =		6,	/* shdr:sh_link */
	SHDR_CMD_T_SH_NAME =		7,	/* shdr:sh_name */
	SHDR_CMD_T_SH_OFFSET =		8,	/* shdr:sh_offset */
	SHDR_CMD_T_SH_SIZE =		9,	/* shdr:sh_size */
	SHDR_CMD_T_SH_TYPE =		10	/* shdr:sh_type */
} SHDR_CMD_T;


#ifndef _ELF64
/*
 * We supply this function for the msg module. Only one copy is needed.
 */
const char *
_shdr_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 shdr_opt_t enum specifies a bit value for every optional
 * argument allowed by a command in this module.
 */
typedef enum {
	SHDR_OPT_F_AND =	1,	/* -and: AND (&) values to dest */
	SHDR_OPT_F_CMP =	2,	/* -cmp: Complement (~) values */
	SHDR_OPT_F_NAMOFFSET =	4,	/* -name_offset: Name arg is numeric */
					/*	 ofset rather than string */
	SHDR_OPT_F_OR =		8,	/* -or: OR (|) values to dest */
	SHDR_OPT_F_SHNDX =	16,	/* -shndx: Section by index, not name */
	SHDR_OPT_F_SHTYP =	32,	/* -shtyp: Section by type, not name */
	SHDR_OPT_F_VALUE_SHNAM = 64,	/* -value_shnam: Value of sh_info or */
					/*	sh_link given as section name */
	SHDR_OPT_F_VALUE_SHTYP = 128	/* -value_shtyp: Value of sh_info or */
					/*	sh_link given as section type */
} shdr_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;
	shdr_opt_t		optmask;	/* Mask of options used */
	int			argc;		/* # of plain arguments */
	const char		**argv;		/* Plain arguments */
} ARGSTATE;


/*
 * Standard argument processing for shdr module
 *
 * entry
 *	obj_state, argc, argv - Standard command arguments
 *	optmask - Mask of allowed optional arguments.
 *	cmd - SHDR_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[],
    SHDR_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 SHDR_CMD_T_DUMP:
		if (argc > 1)
			elfedit_command_usage();
		break;
	case SHDR_CMD_T_SH_FLAGS:
		/* shdr:sh_flags allows an arbitrary number of arguments */
		break;
	default:
		/* The remaining commands accept 2 plain arguments */
		if (argc > 2)
			elfedit_command_usage();
		break;
	}

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


/*
 * Options for deciding which items print_shdr() displays.
 */
typedef enum {
	PRINT_SHDR_ALL,		/* Print all shdr[ndx:ndx+cnt-1] */
	PRINT_SHDR_TYPE,	/* Print all shdr[ndx:ndx+cnt-1] with type */
				/*	 of shdr[ndx] */
	PRINT_SHDR_NAME,	/* Print all shdr[ndx:ndx+cnt-1] with name */
				/*	 of shdr[ndx] */
} PRINT_SHDR_T;

/*
 * Print section 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 - SHDR_CMD_T_* value giving identify of caller
 *	argstate - State block for section header array
 *	ndx - Index of first section to display
 *	cnt - Number of sections to display
 *	print_type - Specifies which items are shown
 */
static void
print_shdr(SHDR_CMD_T cmd, int autoprint, ARGSTATE *argstate,
    Word ndx, Word cnt, PRINT_SHDR_T print_type)
{
	elfedit_outstyle_t	outstyle;
	Ehdr			*ehdr = argstate->obj_state->os_ehdr;
	uchar_t			osabi = ehdr->e_ident[EI_OSABI];
	Half			mach = ehdr->e_machine;
	elfedit_section_t	*ref_sec = &argstate->obj_state->os_secarr[ndx];


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

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

	for (; cnt--; ndx++) {
		elfedit_section_t *sec = &argstate->obj_state->os_secarr[ndx];
		Shdr *shdr = sec->sec_shdr;

		switch (print_type) {
		case PRINT_SHDR_TYPE:
			if (shdr->sh_type != ref_sec->sec_shdr->sh_type)
				continue;
			break;

		case PRINT_SHDR_NAME:
			if (strcmp(sec->sec_name, ref_sec->sec_name) != 0)
				continue;
			break;
		}

		/*
		 * If doing default output, use elfdump style where we
		 * show all section header attributes. In this case, the
		 * command that called us doesn't matter
		 */
		if (outstyle == ELFEDIT_OUTSTYLE_DEFAULT) {
			elfedit_printf(MSG_ORIG(MSG_STR_NL));
			elfedit_printf(MSG_INTL(MSG_ELF_SHDR), ndx,
			    sec->sec_name);
			Elf_shdr(NULL, osabi, mach, sec->sec_shdr);
			continue;
		}

		/* Non-default output is handled case by case */
		switch (cmd) {
		case SHDR_CMD_T_SH_ADDR:
			elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
			    EC_XWORD(shdr->sh_addr));
			break;

		case SHDR_CMD_T_SH_ADDRALIGN:
			elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
			    EC_XWORD(shdr->sh_addralign));
			break;

		case SHDR_CMD_T_SH_ENTSIZE:
			elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
			    EC_XWORD(shdr->sh_entsize));
			break;

		case SHDR_CMD_T_SH_FLAGS:
			if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
				Conv_sec_flags_buf_t sec_flags_buf;

				elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
				    conv_sec_flags(osabi, mach, shdr->sh_flags,
				    CONV_FMT_NOBKT, &sec_flags_buf));
			} else {
				elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
				    EC_XWORD(shdr->sh_flags));
			}
			break;

		case SHDR_CMD_T_SH_INFO:
			elfedit_printf(MSG_ORIG(MSG_FMT_WORDVALNL),
			    EC_WORD(shdr->sh_info));
			break;

		case SHDR_CMD_T_SH_LINK:
			elfedit_printf(MSG_ORIG(MSG_FMT_WORDVALNL),
			    EC_WORD(shdr->sh_link));
			break;

		case SHDR_CMD_T_SH_NAME:
			/*
			 * In simple output mode, we show the string. In
			 * numeric mode, we show the string table offset.
			 */
			if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
				elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
				    sec->sec_name);
			} else {
				elfedit_printf(MSG_ORIG(MSG_FMT_WORDVALNL),
				    EC_WORD(shdr->sh_name));
			}
			break;

		case SHDR_CMD_T_SH_OFFSET:
			elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
			    EC_XWORD(shdr->sh_offset));
			break;

		case SHDR_CMD_T_SH_SIZE:
			elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
			    EC_XWORD(shdr->sh_size));
			break;

		case SHDR_CMD_T_SH_TYPE:
			if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
				Conv_inv_buf_t inv_buf;

				elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
				    conv_sec_type(osabi, mach, shdr->sh_type, 0,
				    &inv_buf));
			} else {
				elfedit_printf(MSG_ORIG(MSG_FMT_WORDHEXNL),
				    EC_WORD(shdr->sh_type));
			}
			break;
		}
	}
}


/*
 * Common body for the shdr: 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 SHDR_CMD_T_* constants listed above, specifying
 *		which command to implement.
 *	obj_state, argc, argv - Standard command arguments
 */
static elfedit_cmdret_t
cmd_body(SHDR_CMD_T cmd, elfedit_obj_state_t *obj_state,
    int argc, const char *argv[])
{
	Ehdr			*ehdr = obj_state->os_ehdr;
	uchar_t			osabi = ehdr->e_ident[EI_OSABI];
	Half			mach = ehdr->e_machine;
	ARGSTATE		argstate;
	Word			ndx;
	elfedit_section_t	*shdr_sec;
	Shdr			*shdr;
	elfedit_cmdret_t	ret = ELFEDIT_CMDRET_NONE;
	PRINT_SHDR_T		print_type;

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

	/* If there are no arguments, dump the whole table and return */
	if (argstate.argc == 0) {
		print_shdr(cmd, 0, &argstate, 0, obj_state->os_shnum,
		    PRINT_SHDR_ALL);
		return (ELFEDIT_CMDRET_NONE);
	}

	/*
	 * The first argument gives the section to use. This can be a
	 * name (default), section index, or section type, depending on
	 * the options used.
	 */
	if (argstate.optmask & SHDR_OPT_F_SHNDX) {
		ndx = elfedit_atoshndx(argstate.argv[0], obj_state->os_shnum);
		print_type = PRINT_SHDR_ALL;
	} else if (argstate.optmask & SHDR_OPT_F_SHTYP) {
		ndx = elfedit_type_to_shndx(obj_state,
		    elfedit_atoconst(argstate.argv[0], ELFEDIT_CONST_SHT));
		print_type = PRINT_SHDR_TYPE;
	} else {
		ndx = elfedit_name_to_shndx(obj_state, argstate.argv[0]);
		print_type = PRINT_SHDR_NAME;
	}

	/* If there is a single argument, display that item and return */
	if (argstate.argc == 1) {
		Word	cnt;

		cnt = (print_type == PRINT_SHDR_ALL) ?
		    1 : obj_state->os_shnum - ndx;
		print_shdr(cmd, 0, &argstate, ndx, cnt, print_type);
		return (ELFEDIT_CMDRET_NONE);
	}

	/*
	 * Section [0] is supposed to be all zero unless extended sections
	 * are in force. Rather than setting extended values directly,
	 * it is expected to be handled by libelf. So, a direct change here
	 * is probably not what was intended.
	 */
	if (ndx == 0)
		elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_CHGSHDR0));

	/* The second value is an integer giving a new value */
	shdr_sec = &obj_state->os_secarr[ndx];
	shdr = shdr_sec->sec_shdr;
	switch (cmd) {
		/*
		 * SHDR_CMD_T_DUMP can't get here: It never has more than
		 * one argument, and is handled above.
		 */

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

			if (shdr->sh_addr == sh_addr) {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_LLX_OK),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_ADDR),
				    EC_ADDR(shdr->sh_addr));
			} else {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_LLX_CHG),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_ADDR),
				    EC_ADDR(shdr->sh_addr), EC_ADDR(sh_addr));
				ret = ELFEDIT_CMDRET_MOD;
				shdr->sh_addr = sh_addr;
			}
		}
		break;

	case SHDR_CMD_T_SH_ADDRALIGN:
		{
			Xword	sh_addralign;

			sh_addralign = elfedit_atoui(argstate.argv[1], NULL);
			if (elfedit_bits_set(sh_addralign,
			    sizeof (sh_addralign)) > 1)
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_ADDRALIGN),
				    argstate.argv[1]);
			if (shdr->sh_addralign == sh_addralign) {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_LLX_OK),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_ADDRALIGN),
				    EC_XWORD(shdr->sh_addralign));
			} else {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_LLX_CHG),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_ADDRALIGN),
				    EC_XWORD(shdr->sh_addralign),
				    EC_XWORD(sh_addralign));
				ret = ELFEDIT_CMDRET_MOD;
				shdr->sh_addralign = sh_addralign;
			}
		}
		break;

	case SHDR_CMD_T_SH_ENTSIZE:
		{
			Xword sh_entsize;

			sh_entsize = elfedit_atoui(argstate.argv[1], NULL);
			if (shdr->sh_entsize == sh_entsize) {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_LLX_OK),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_ENTSIZE),
				    EC_XWORD(shdr->sh_entsize));
			} else {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_LLX_CHG),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_ENTSIZE),
				    EC_XWORD(shdr->sh_entsize),
				    EC_XWORD(sh_entsize));
				ret = ELFEDIT_CMDRET_MOD;
				shdr->sh_entsize = sh_entsize;
			}
		}
		break;

	case SHDR_CMD_T_SH_FLAGS:
		{
			Conv_sec_flags_buf_t buf1, buf2;
			Word	sh_flags = 0;
			int	i;

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

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

			/* Perform any requested bit operations */
			if (argstate.optmask & SHDR_OPT_F_AND)
				sh_flags &= shdr->sh_flags;
			else if (argstate.optmask & SHDR_OPT_F_OR)
				sh_flags |= shdr->sh_flags;

			/* Set the value */
			if (shdr->sh_flags == sh_flags) {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_S_OK),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_FLAGS),
				    conv_sec_flags(osabi, mach,
				    shdr->sh_flags, 0, &buf1));
			} else {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_S_CHG),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_FLAGS),
				    conv_sec_flags(osabi, mach,
				    shdr->sh_flags, 0, &buf1),
				    conv_sec_flags(osabi, mach,
				    sh_flags, 0, &buf2));
				ret = ELFEDIT_CMDRET_MOD;
				shdr->sh_flags = sh_flags;
			}
		}
		break;

	case SHDR_CMD_T_SH_INFO:
		{
			Word sh_info;

			if (argstate.optmask & SHDR_OPT_F_VALUE_SHNAM)
				sh_info = elfedit_name_to_shndx(obj_state,
				    argstate.argv[1]);
			else if (argstate.optmask & SHDR_OPT_F_VALUE_SHTYP)
				sh_info = elfedit_type_to_shndx(obj_state,
				    elfedit_atoconst(argstate.argv[1],
				    ELFEDIT_CONST_SHT));
			else
				sh_info = elfedit_atoui(argstate.argv[1], NULL);

			if (shdr->sh_info == sh_info) {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_D_OK),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_INFO),
				    EC_WORD(shdr->sh_info));
			} else {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_D_CHG),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_INFO),
				    EC_WORD(shdr->sh_info), EC_WORD(sh_info));
				ret = ELFEDIT_CMDRET_MOD;
				shdr->sh_info = sh_info;
			}
		}
		break;

	case SHDR_CMD_T_SH_LINK:
		{
			Word sh_link;

			if (argstate.optmask & SHDR_OPT_F_VALUE_SHNAM)
				sh_link = elfedit_name_to_shndx(obj_state,
				    argstate.argv[1]);
			else if (argstate.optmask & SHDR_OPT_F_VALUE_SHTYP)
				sh_link = elfedit_type_to_shndx(obj_state,
				    elfedit_atoconst(argstate.argv[1],
				    ELFEDIT_CONST_SHT));
			else
				sh_link = elfedit_atoui(argstate.argv[1], NULL);

			if (shdr->sh_link == sh_link) {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_D_OK),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_LINK),
				    EC_WORD(shdr->sh_link));
			} else {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_D_CHG),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_LINK),
				    EC_WORD(shdr->sh_link), EC_WORD(sh_link));
				ret = ELFEDIT_CMDRET_MOD;
				shdr->sh_link = sh_link;
			}
		}
		break;

	case SHDR_CMD_T_SH_NAME:
		{
			elfedit_section_t *shstr_sec =
			    &obj_state->os_secarr[obj_state->os_shstrndx];
			Word sh_name;

			/*
			 * If -name_offset was specified, this is an offset
			 * into the string table. Otherwise it is a string
			 * we need to turn into an offset.
			 */
			sh_name = (argstate.optmask & SHDR_OPT_F_NAMOFFSET) ?
			    elfedit_atoui(argstate.argv[1], NULL) :
			    elfedit_strtab_insert(obj_state,
			    shstr_sec, NULL, argstate.argv[1]);
			if (shdr->sh_name == sh_name) {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_D_OK),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_NAME),
				    EC_WORD(shdr->sh_name));
			} else {
				/*
				 * The section name is cached, so we must
				 * also update that value. This call will
				 * warn if the offset is out of range, and
				 * will supply a safe string in that case.
				 */
				shdr_sec->sec_name =
				    elfedit_offset_to_str(shstr_sec,
				    sh_name, ELFEDIT_MSG_DEBUG, 1);

				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_D_CHG),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_NAME),
				    EC_WORD(shdr->sh_name), EC_WORD(sh_name));
				ret = ELFEDIT_CMDRET_MOD;
				shdr->sh_name = sh_name;
			}
		}
		break;

	case SHDR_CMD_T_SH_OFFSET:
		{
			Off sh_offset;

			sh_offset = elfedit_atoui(argstate.argv[1], NULL);
			if (shdr->sh_offset == sh_offset) {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_LLX_OK),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_OFFSET),
				    EC_XWORD(shdr->sh_offset));
			} else {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_LLX_CHG),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_OFFSET),
				    EC_XWORD(shdr->sh_offset),
				    EC_XWORD(sh_offset));
				ret = ELFEDIT_CMDRET_MOD;
				shdr->sh_offset = sh_offset;
			}
		}
		break;

	case SHDR_CMD_T_SH_SIZE:
		{
			Xword sh_size;

			sh_size = elfedit_atoui(argstate.argv[1], NULL);
			if (shdr->sh_size == sh_size) {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_LLX_OK),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_SIZE),
				    EC_XWORD(shdr->sh_size));
			} else {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_LLX_CHG),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_SIZE),
				    EC_XWORD(shdr->sh_size),
				    EC_XWORD(sh_size));
				ret = ELFEDIT_CMDRET_MOD;
				shdr->sh_size = sh_size;
			}
		}
		break;

	case SHDR_CMD_T_SH_TYPE:
		{
			Word sh_type = elfedit_atoconst(argstate.argv[1],
			    ELFEDIT_CONST_SHT);
			Conv_inv_buf_t inv_buf1, inv_buf2;

			if (shdr->sh_type == sh_type) {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_S_OK),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_TYPE),
				    conv_sec_type(osabi, mach, shdr->sh_type,
				    0, &inv_buf1));
			} else {
				elfedit_msg(ELFEDIT_MSG_DEBUG,
				    MSG_INTL(MSG_DEBUG_S_CHG),
				    ndx, shdr_sec->sec_name,
				    MSG_ORIG(MSG_CMD_SH_TYPE),
				    conv_sec_type(osabi, mach, shdr->sh_type,
				    0, &inv_buf1),
				    conv_sec_type(osabi, mach, sh_type,
				    0, &inv_buf2));
				ret = ELFEDIT_CMDRET_MOD;
				shdr->sh_type = sh_type;
			}
		}
		break;
	}

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

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

	return (ret);
}


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

/*
 * All of the commands accept the same first argument (sec) that
 * specifies the section. This argument can be a section name
 * (default), section index, or section type, depending on the
 * options used. This routine determines which case is current,
 * and then supplies completion for the first argument.
 */
static void
cpl_1starg_sec(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
    const char *argv[], int num_opt)
{
	elfedit_section_t *sec;
	enum { NAME, INDEX, TYPE } op;
	Word ndx;

	if (argc != (num_opt + 1))
		return;

	op = NAME;
	for (ndx = 0; ndx < num_opt; ndx++) {
		if (strcmp(argv[ndx], MSG_ORIG(MSG_STR_MINUS_SHNDX)) == 0)
			op = INDEX;
		else if (strcmp(argv[ndx], MSG_ORIG(MSG_STR_MINUS_SHTYP)) == 0)
			op = TYPE;
	}

	switch (op) {
	case NAME:
		if (obj_state == NULL)
			break;
		sec = obj_state->os_secarr;
		for (ndx = 0; ndx < obj_state->os_shnum; ndx++, sec++)
			elfedit_cpl_match(cpldata, sec->sec_name, 0);
		break;

	case INDEX:
		elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHN);
		break;

	case TYPE:
		elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHT);
		break;
	}
}


/*ARGSUSED*/
static void
cpl_sh_flags(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
    const char *argv[], int num_opt)
{
	/* Handle -shXXX options */
	cpl_1starg_sec(obj_state, cpldata, argc, argv, num_opt);

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

/*
 * For shdr:sh_info and shdr:sh_link: The value argument can be an
 * integer, section name, or section type.
 */
/*ARGSUSED*/
static void
cpl_sh_infolink(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
    const char *argv[], int num_opt)
{
	elfedit_section_t *sec;
	enum { NAME, INTVAL, TYPE } op;
	Word ndx;

	/* Handle -shXXX options */
	cpl_1starg_sec(obj_state, cpldata, argc, argv, num_opt);

	if (argc != (num_opt + 2))
		return;

	op = INTVAL;
	for (ndx = 0; ndx < num_opt; ndx++) {
		if (strcmp(argv[ndx], MSG_ORIG(MSG_STR_MINUS_VALUE_SHNAM)) == 0)
			op = NAME;
		else if (strcmp(argv[ndx],
		    MSG_ORIG(MSG_STR_MINUS_VALUE_SHTYP)) == 0)
			op = TYPE;
	}

	switch (op) {
	case NAME:
		if (obj_state == NULL)
			break;
		sec = obj_state->os_secarr;
		for (ndx = 0; ndx < obj_state->os_shnum; ndx++, sec++)
			elfedit_cpl_match(cpldata, sec->sec_name, 0);
		break;

	case TYPE:
		elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHT);
		break;
	}
}

/*ARGSUSED*/
static void
cpl_sh_type(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
    const char *argv[], int num_opt)
{
	/* Handle -shXXX options */
	cpl_1starg_sec(obj_state, cpldata, argc, argv, num_opt);

	/* The second argument can be an SHT_ value */
	if (argc == (num_opt + 2))
		elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHT);
}


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


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


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


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

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

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

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

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

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

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

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


/*ARGSUSED*/
elfedit_module_t *
elfedit_init(elfedit_module_version_t version)
{
	/* Multiple commands accept only the 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_SHNDX),
		    /* MSG_INTL(MSG_OPTDESC_SHNDX) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
		    SHDR_OPT_F_SHNDX, SHDR_OPT_F_SHTYP },
		{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
		    /* MSG_INTL(MSG_OPTDESC_SHTYP) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
		    SHDR_OPT_F_SHTYP, SHDR_OPT_F_SHNDX },
		{ NULL }
	};

	/*
	 * sh_info and sh_link accept the standard options above,
	 * plus -value_shnam and -value_shtyp.
	 */
	static elfedit_cmd_optarg_t opt_infolink[] = {
		{ ELFEDIT_STDOA_OPT_O, 0,
		    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
		{ MSG_ORIG(MSG_STR_MINUS_SHNDX),
		    /* MSG_INTL(MSG_OPTDESC_SHNDX) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
		    SHDR_OPT_F_SHNDX, SHDR_OPT_F_SHTYP },
		{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
		    /* MSG_INTL(MSG_OPTDESC_SHTYP) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
		    SHDR_OPT_F_SHTYP, SHDR_OPT_F_SHNDX },
		{ MSG_ORIG(MSG_STR_MINUS_VALUE_SHNAM),
		    /* MSG_INTL(MSG_OPTDESC_VALUE_SHNAM) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_VALUE_SHNAM), 0,
		    SHDR_OPT_F_VALUE_SHNAM, SHDR_OPT_F_VALUE_SHNAM },
		{ MSG_ORIG(MSG_STR_MINUS_VALUE_SHTYP),
		    /* MSG_INTL(MSG_OPTDESC_VALUE_SHTYP) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_VALUE_SHTYP), 0,
		    SHDR_OPT_F_VALUE_SHTYP, SHDR_OPT_F_VALUE_SHTYP },
		{ NULL }
	};

	/* shdr:sh_addr */
	static const char *name_sh_addr[] = {
	    MSG_ORIG(MSG_CMD_SH_ADDR), NULL };
	static elfedit_cmd_optarg_t arg_sh_addr[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ MSG_ORIG(MSG_STR_VALUE),
		    /* MSG_INTL(MSG_A2_DESC_SH_ADDR) */
		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_ADDR),
		    ELFEDIT_CMDOA_F_OPT },
		{ NULL }
	};

	/* shdr: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_SHNDX),
		    /* MSG_INTL(MSG_OPTDESC_SHNDX) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
		    SHDR_OPT_F_SHNDX, SHDR_OPT_F_SHTYP },
		{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
		    /* MSG_INTL(MSG_OPTDESC_SHTYP) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
		    SHDR_OPT_F_SHTYP, SHDR_OPT_F_SHNDX },
		{ NULL }
	};
	static elfedit_cmd_optarg_t arg_dump[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ NULL }
	};

	/* shdr:sh_addralign */
	static const char *name_sh_addralign[] = {
	    MSG_ORIG(MSG_CMD_SH_ADDRALIGN), NULL };
	static elfedit_cmd_optarg_t arg_sh_addralign[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ MSG_ORIG(MSG_STR_VALUE),
		    /* MSG_INTL(MSG_A2_DESC_SH_ADDRALIGN) */
		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_ADDRALIGN),
		    ELFEDIT_CMDOA_F_OPT },
		{ NULL }
	};

	/* shdr:sh_entsize */
	static const char *name_sh_entsize[] = {
	    MSG_ORIG(MSG_CMD_SH_ENTSIZE), NULL };
	static elfedit_cmd_optarg_t arg_sh_entsize[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ MSG_ORIG(MSG_STR_VALUE),
		    /* MSG_INTL(MSG_A2_DESC_SH_ENTSIZE) */
		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_ENTSIZE),
		    ELFEDIT_CMDOA_F_OPT },
		{ NULL }
	};

	/* shdr:sh_flags */
	static const char *name_sh_flags[] = {
	    MSG_ORIG(MSG_CMD_SH_FLAGS), NULL };
	static elfedit_cmd_optarg_t opt_sh_flags[] = {
		{ ELFEDIT_STDOA_OPT_AND, 0,
		    ELFEDIT_CMDOA_F_INHERIT, SHDR_OPT_F_AND, SHDR_OPT_F_OR },
		{ ELFEDIT_STDOA_OPT_CMP, 0,
		    ELFEDIT_CMDOA_F_INHERIT, SHDR_OPT_F_CMP, 0 },
		{ ELFEDIT_STDOA_OPT_O, 0,
		    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
		{ ELFEDIT_STDOA_OPT_OR, 0,
		    ELFEDIT_CMDOA_F_INHERIT, SHDR_OPT_F_OR, SHDR_OPT_F_AND },
		{ MSG_ORIG(MSG_STR_MINUS_SHNDX),
		    /* MSG_INTL(MSG_OPTDESC_SHNDX) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
		    SHDR_OPT_F_SHNDX, SHDR_OPT_F_SHTYP },
		{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
		    /* MSG_INTL(MSG_OPTDESC_SHTYP) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
		    SHDR_OPT_F_SHTYP, SHDR_OPT_F_SHNDX },
		{ NULL }
	};
	static elfedit_cmd_optarg_t arg_sh_flags[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ MSG_ORIG(MSG_STR_VALUE),
		    /* MSG_INTL(MSG_A2_DESC_SH_FLAGS) */
		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_FLAGS),
		    ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT },
		{ NULL }
	};

	/* shdr:sh_info */
	static const char *name_sh_info[] = {
	    MSG_ORIG(MSG_CMD_SH_INFO), NULL };
	static elfedit_cmd_optarg_t arg_sh_info[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ MSG_ORIG(MSG_STR_VALUE),
		    /* MSG_INTL(MSG_A2_DESC_SH_INFO) */
		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_INFO),
		    ELFEDIT_CMDOA_F_OPT },
		{ NULL }
	};

	/* shdr:sh_link */
	static const char *name_sh_link[] = {
	    MSG_ORIG(MSG_CMD_SH_LINK), NULL };
	static elfedit_cmd_optarg_t arg_sh_link[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ MSG_ORIG(MSG_STR_VALUE),
		    /* MSG_INTL(MSG_A2_DESC_SH_LINK) */
		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_LINK),
		    ELFEDIT_CMDOA_F_OPT },
		{ NULL }
	};

	/* shdr:sh_name */
	static const char *name_sh_name[] = {
	    MSG_ORIG(MSG_CMD_SH_NAME), NULL };
	static elfedit_cmd_optarg_t opt_sh_name[] = {
		{ MSG_ORIG(MSG_STR_MINUS_NAME_OFFSET),
		    /* MSG_INTL(MSG_OPTDESC_NAME_OFFSET) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_NAME_OFFSET), 0,
		    SHDR_OPT_F_NAMOFFSET, 0 },
		{ ELFEDIT_STDOA_OPT_O, 0,
		    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
		{ MSG_ORIG(MSG_STR_MINUS_SHNDX),
		    /* MSG_INTL(MSG_OPTDESC_SHNDX) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
		    SHDR_OPT_F_SHNDX, SHDR_OPT_F_SHTYP },
		{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
		    /* MSG_INTL(MSG_OPTDESC_SHTYP) */
		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
		    SHDR_OPT_F_SHTYP, SHDR_OPT_F_SHNDX },
		{ NULL }
	};
	static elfedit_cmd_optarg_t arg_sh_name[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ MSG_ORIG(MSG_STR_NAME),
		    /* MSG_INTL(MSG_A2_DESC_SH_NAME) */
		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_NAME),
		    ELFEDIT_CMDOA_F_OPT },
		{ NULL }
	};

	/* shdr:sh_offset */
	static const char *name_sh_offset[] = {
	    MSG_ORIG(MSG_CMD_SH_OFFSET), NULL };
	static elfedit_cmd_optarg_t arg_sh_offset[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ MSG_ORIG(MSG_STR_VALUE),
		    /* MSG_INTL(MSG_A2_DESC_SH_OFFSET) */
		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_OFFSET),
		    ELFEDIT_CMDOA_F_OPT },
		{ NULL }
	};

	/* shdr:sh_size */
	static const char *name_sh_size[] = {
	    MSG_ORIG(MSG_CMD_SH_SIZE), NULL };
	static elfedit_cmd_optarg_t arg_sh_size[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ MSG_ORIG(MSG_STR_VALUE),
		    /* MSG_INTL(MSG_A2_DESC_SH_SIZE) */
		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_SIZE),
		    ELFEDIT_CMDOA_F_OPT },
		{ NULL }
	};

	/* shdr:sh_type */
	static const char *name_sh_type[] = {
	    MSG_ORIG(MSG_CMD_SH_TYPE), NULL };
	static elfedit_cmd_optarg_t arg_sh_type[] = {
		{ MSG_ORIG(MSG_STR_SEC),
		    /* MSG_INTL(MSG_A1_SEC) */
		    ELFEDIT_I18NHDL(MSG_A1_SEC),
		    ELFEDIT_CMDOA_F_OPT },
		{ MSG_ORIG(MSG_STR_VALUE),
		    /* MSG_INTL(MSG_A2_DESC_SH_TYPE) */
		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_TYPE),
		    ELFEDIT_CMDOA_F_OPT },
		{ NULL }
	};

	static elfedit_cmd_t cmds[] = {
		/* shdr:dump */
		{ cmd_dump, cpl_1starg_sec, 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 },

		/* shdr:sh_addr */
		{ cmd_sh_addr, cpl_1starg_sec, name_sh_addr,
		    /* MSG_INTL(MSG_DESC_SH_ADDR) */
		    ELFEDIT_I18NHDL(MSG_DESC_SH_ADDR),
		    /* MSG_INTL(MSG_HELP_SH_ADDR) */
		    ELFEDIT_I18NHDL(MSG_HELP_SH_ADDR),
		    opt_std, arg_sh_addr },

		/* shdr:sh_addralign */
		{ cmd_sh_addralign, cpl_1starg_sec, name_sh_addralign,
		    /* MSG_INTL(MSG_DESC_SH_ADDRALIGN) */
		    ELFEDIT_I18NHDL(MSG_DESC_SH_ADDRALIGN),
		    /* MSG_INTL(MSG_HELP_SH_ADDRALIGN) */
		    ELFEDIT_I18NHDL(MSG_HELP_SH_ADDRALIGN),
		    opt_std, arg_sh_addralign },

		/* shdr:sh_entsize */
		{ cmd_sh_entsize, cpl_1starg_sec, name_sh_entsize,
		    /* MSG_INTL(MSG_DESC_SH_ENTSIZE) */
		    ELFEDIT_I18NHDL(MSG_DESC_SH_ENTSIZE),
		    /* MSG_INTL(MSG_HELP_SH_ENTSIZE) */
		    ELFEDIT_I18NHDL(MSG_HELP_SH_ENTSIZE),
		    opt_std, arg_sh_entsize },

		/* shdr:sh_flags */
		{ cmd_sh_flags, cpl_sh_flags, name_sh_flags,
		    /* MSG_INTL(MSG_DESC_SH_FLAGS) */
		    ELFEDIT_I18NHDL(MSG_DESC_SH_FLAGS),
		    /* MSG_INTL(MSG_HELP_SH_FLAGS) */
		    ELFEDIT_I18NHDL(MSG_HELP_SH_FLAGS),
		    opt_sh_flags, arg_sh_flags },

		/* shdr:sh_info */
		{ cmd_sh_info, cpl_sh_infolink, name_sh_info,
		    /* MSG_INTL(MSG_DESC_SH_INFO) */
		    ELFEDIT_I18NHDL(MSG_DESC_SH_INFO),
		    /* MSG_INTL(MSG_HELP_SH_INFO) */
		    ELFEDIT_I18NHDL(MSG_HELP_SH_INFO),
		    opt_infolink, arg_sh_info },

		/* shdr:sh_link */
		{ cmd_sh_link, cpl_sh_infolink, name_sh_link,
		    /* MSG_INTL(MSG_DESC_SH_LINK) */
		    ELFEDIT_I18NHDL(MSG_DESC_SH_LINK),
		    /* MSG_INTL(MSG_HELP_SH_LINK) */
		    ELFEDIT_I18NHDL(MSG_HELP_SH_LINK),
		    opt_infolink, arg_sh_link },

		/* shdr:sh_name */
		{ cmd_sh_name, cpl_1starg_sec, name_sh_name,
		    /* MSG_INTL(MSG_DESC_SH_NAME) */
		    ELFEDIT_I18NHDL(MSG_DESC_SH_NAME),
		    /* MSG_INTL(MSG_HELP_SH_NAME) */
		    ELFEDIT_I18NHDL(MSG_HELP_SH_NAME),
		    opt_sh_name, arg_sh_name },

		/* shdr:sh_offset */
		{ cmd_sh_offset, cpl_1starg_sec, name_sh_offset,
		    /* MSG_INTL(MSG_DESC_SH_OFFSET) */
		    ELFEDIT_I18NHDL(MSG_DESC_SH_OFFSET),
		    /* MSG_INTL(MSG_HELP_SH_OFFSET) */
		    ELFEDIT_I18NHDL(MSG_HELP_SH_OFFSET),
		    opt_std, arg_sh_offset },

		/* shdr:sh_size */
		{ cmd_sh_size, cpl_1starg_sec, name_sh_size,
		    /* MSG_INTL(MSG_DESC_SH_SIZE) */
		    ELFEDIT_I18NHDL(MSG_DESC_SH_SIZE),
		    /* MSG_INTL(MSG_HELP_SH_SIZE) */
		    ELFEDIT_I18NHDL(MSG_HELP_SH_SIZE),
		    opt_std, arg_sh_size },

		/* shdr:sh_type */
		{ cmd_sh_type, cpl_sh_type, name_sh_type,
		    /* MSG_INTL(MSG_DESC_SH_TYPE) */
		    ELFEDIT_I18NHDL(MSG_DESC_SH_TYPE),
		    /* MSG_INTL(MSG_HELP_SH_TYPE) */
		    ELFEDIT_I18NHDL(MSG_HELP_SH_TYPE),
		    opt_std, arg_sh_type },

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