xref: /titanic_44/usr/src/cmd/sgs/elfedit/modules/common/shdr.c (revision 3f7d54a6b84904c8f4d8daa4c7b577bede7df8b9)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include	<stdio.h>
28 #include	<unistd.h>
29 #include	<elfedit.h>
30 #include	<sys/elf_SPARC.h>
31 #include	<sys/elf_amd64.h>
32 #include	<strings.h>
33 #include	<debug.h>
34 #include	<conv.h>
35 #include	<shdr_msg.h>
36 
37 
38 
39 
40 /*
41  * This module uses shared code for several of the commands.
42  * It is sometimes necessary to know which specific command
43  * is active.
44  */
45 typedef enum {
46 	SHDR_CMD_T_DUMP =		0,	/* shdr:dump */
47 
48 	SHDR_CMD_T_SH_ADDR =		1,	/* shdr:sh_addr */
49 	SHDR_CMD_T_SH_ADDRALIGN =	2,	/* shdr:sh_addralign */
50 	SHDR_CMD_T_SH_ENTSIZE =		3,	/* shdr:sh_entsize */
51 	SHDR_CMD_T_SH_FLAGS =		4,	/* shdr:sh_flags */
52 	SHDR_CMD_T_SH_INFO =		5,	/* shdr:sh_info */
53 	SHDR_CMD_T_SH_LINK =		6,	/* shdr:sh_link */
54 	SHDR_CMD_T_SH_NAME =		7,	/* shdr:sh_name */
55 	SHDR_CMD_T_SH_OFFSET =		8,	/* shdr:sh_offset */
56 	SHDR_CMD_T_SH_SIZE =		9,	/* shdr:sh_size */
57 	SHDR_CMD_T_SH_TYPE =		10	/* shdr:sh_type */
58 } SHDR_CMD_T;
59 
60 
61 
62 #ifndef _ELF64
63 /*
64  * We supply this function for the msg module. Only one copy is needed.
65  */
66 const char *
67 _shdr_msg(Msg mid)
68 {
69 	return (gettext(MSG_ORIG(mid)));
70 }
71 
72 #endif
73 
74 
75 
76 /*
77  * This function is supplied to elfedit through our elfedit_module_t
78  * definition. It translates the opaque elfedit_i18nhdl_t handles
79  * in our module interface into the actual strings for elfedit to
80  * use.
81  *
82  * note:
83  *	This module uses Msg codes for its i18n handle type.
84  *	So the translation is simply to use MSG_INTL() to turn
85  *	it into a string and return it.
86  */
87 static const char *
88 mod_i18nhdl_to_str(elfedit_i18nhdl_t hdl)
89 {
90 	Msg msg = (Msg)hdl;
91 
92 	return (MSG_INTL(msg));
93 }
94 
95 
96 
97 /*
98  * The shdr_opt_t enum specifies a bit value for every optional
99  * argument allowed by a command in this module.
100  */
101 typedef enum {
102 	SHDR_OPT_F_AND =	1,	/* -and: AND (&) values to dest */
103 	SHDR_OPT_F_CMP =	2,	/* -cmp: Complement (~) values */
104 	SHDR_OPT_F_NAMOFFSET =	4,	/* -name_offset: Name arg is numeric */
105 					/*	 ofset rather than string */
106 	SHDR_OPT_F_OR =		8,	/* -or: OR (|) values to dest */
107 	SHDR_OPT_F_SHNDX =	16,	/* -shndx: Section by index, not name */
108 	SHDR_OPT_F_SHTYP =	32,	/* -shtyp: Section by type, not name */
109 	SHDR_OPT_F_VALUE_SHNAM = 64,	/* -value_shnam: Value of sh_info or */
110 					/*	sh_link given as section name */
111 	SHDR_OPT_F_VALUE_SHTYP = 128	/* -value_shtyp: Value of sh_info or */
112 					/*	sh_link given as section type */
113 } shdr_opt_t;
114 
115 
116 /*
117  * A variable of type ARGSTATE is used by each command to maintain
118  * information about the section headers and related things. It is
119  * initialized by process_args(), and used by the other routines.
120  */
121 typedef struct {
122 	elfedit_obj_state_t	*obj_state;
123 	shdr_opt_t		optmask;   	/* Mask of options used */
124 	int			argc;		/* # of plain arguments */
125 	const char		**argv;		/* Plain arguments */
126 } ARGSTATE;
127 
128 
129 
130 
131 /*
132  * Standard argument processing for shdr module
133  *
134  * entry
135  *	obj_state, argc, argv - Standard command arguments
136  *	optmask - Mask of allowed optional arguments.
137  *	cmd - SHDR_CMD_T_* value giving identify of caller
138  *	argstate - Address of ARGSTATE block to be initialized
139  *
140  * exit:
141  *	On success, *argstate is initialized. On error,
142  *	an error is issued and this routine does not return.
143  */
144 static void
145 process_args(elfedit_obj_state_t *obj_state, int argc, const char *argv[],
146     SHDR_CMD_T cmd, ARGSTATE *argstate)
147 {
148 	elfedit_getopt_state_t	getopt_state;
149 	elfedit_getopt_ret_t	*getopt_ret;
150 
151 	bzero(argstate, sizeof (*argstate));
152 	argstate->obj_state = obj_state;
153 
154 	elfedit_getopt_init(&getopt_state, &argc, &argv);
155 
156 	/* Add each new option to the options mask */
157 	while ((getopt_ret = elfedit_getopt(&getopt_state)) != NULL)
158 		argstate->optmask |= getopt_ret->gor_idmask;
159 
160 	/* Are the right number of plain arguments present? */
161 	switch (cmd) {
162 	case SHDR_CMD_T_DUMP:
163 		if (argc > 1)
164 			elfedit_command_usage();
165 		break;
166 	case SHDR_CMD_T_SH_FLAGS:
167 		/* shdr:sh_flags allows an arbitrary number of arguments */
168 		break;
169 	default:
170 		/* The remaining commands accept 2 plain arguments */
171 		if (argc > 2)
172 			elfedit_command_usage();
173 		break;
174 	}
175 
176 	/* If there may be an arbitrary amount of output, use a pager */
177 	if (argc == 0)
178 		elfedit_pager_init();
179 
180 	/* Return the updated values of argc/argv */
181 	argstate->argc = argc;
182 	argstate->argv = argv;
183 }
184 
185 
186 
187 /*
188  * Options for deciding which items print_shdr() displays.
189  */
190 typedef enum {
191 	PRINT_SHDR_ALL,		/* Print all shdr[ndx:ndx+cnt-1] */
192 	PRINT_SHDR_TYPE,	/* Print all shdr[ndx:ndx+cnt-1] with type */
193 				/*	 of shdr[ndx] */
194 	PRINT_SHDR_NAME,	/* Print all shdr[ndx:ndx+cnt-1] with name */
195 				/*	 of shdr[ndx] */
196 } PRINT_SHDR_T;
197 
198 /*
199  * Print section header values, taking the calling command, and output style
200  * into account.
201  *
202  * entry:
203  *	autoprint - If True, output is only produced if the elfedit
204  *		autoprint flag is set. If False, output is always produced.
205  *	cmd - SHDR_CMD_T_* value giving identify of caller
206  *	argstate - State block for section header array
207  *	ndx - Index of first section to display
208  *	cnt - Number of sections to display
209  *	print_type - Specifies which items are shown
210  */
211 static void
212 print_shdr(SHDR_CMD_T cmd, int autoprint, ARGSTATE *argstate,
213     Word ndx, Word cnt, PRINT_SHDR_T print_type)
214 {
215 	elfedit_outstyle_t	outstyle;
216 	Ehdr			*ehdr = argstate->obj_state->os_ehdr;
217 	uchar_t			osabi = ehdr->e_ident[EI_OSABI];
218 	Half			mach = ehdr->e_machine;
219 	elfedit_section_t 	*ref_sec = &argstate->obj_state->os_secarr[ndx];
220 
221 
222 	if ((autoprint && ((elfedit_flags() & ELFEDIT_F_AUTOPRINT) == 0)) ||
223 	    (cnt == 0))
224 		return;
225 
226 	/*
227 	 * Pick an output style. shdr:dump is required to use the default
228 	 * style. The other commands use the current output style.
229 	 */
230 	outstyle = (cmd == SHDR_CMD_T_DUMP) ?
231 	    ELFEDIT_OUTSTYLE_DEFAULT : elfedit_outstyle();
232 
233 	for (; cnt--; ndx++) {
234 		elfedit_section_t *sec = &argstate->obj_state->os_secarr[ndx];
235 		Shdr *shdr = sec->sec_shdr;
236 
237 		switch (print_type) {
238 		case PRINT_SHDR_TYPE:
239 			if (shdr->sh_type != ref_sec->sec_shdr->sh_type)
240 				continue;
241 			break;
242 
243 		case PRINT_SHDR_NAME:
244 			if (strcmp(sec->sec_name, ref_sec->sec_name) != 0)
245 				continue;
246 			break;
247 		}
248 
249 		/*
250 		 * If doing default output, use elfdump style where we
251 		 * show all section header attributes. In this case, the
252 		 * command that called us doesn't matter
253 		 */
254 		if (outstyle == ELFEDIT_OUTSTYLE_DEFAULT) {
255 			elfedit_printf(MSG_ORIG(MSG_STR_NL));
256 			elfedit_printf(MSG_INTL(MSG_ELF_SHDR), ndx,
257 			    sec->sec_name);
258 			Elf_shdr(NULL, osabi, mach, sec->sec_shdr);
259 			continue;
260 		}
261 
262 		/* Non-default output is handled case by case */
263 		switch (cmd) {
264 		case SHDR_CMD_T_SH_ADDR:
265 			elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
266 			    EC_XWORD(shdr->sh_addr));
267 			break;
268 
269 		case SHDR_CMD_T_SH_ADDRALIGN:
270 			elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
271 			    EC_XWORD(shdr->sh_addralign));
272 			break;
273 
274 		case SHDR_CMD_T_SH_ENTSIZE:
275 			elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
276 			    EC_XWORD(shdr->sh_entsize));
277 			break;
278 
279 		case SHDR_CMD_T_SH_FLAGS:
280 			if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
281 				Conv_sec_flags_buf_t sec_flags_buf;
282 
283 				elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
284 				    conv_sec_flags(osabi, mach, shdr->sh_flags,
285 				    CONV_FMT_NOBKT, &sec_flags_buf));
286 			} else {
287 				elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
288 				    EC_XWORD(shdr->sh_flags));
289 			}
290 			break;
291 
292 		case SHDR_CMD_T_SH_INFO:
293 			elfedit_printf(MSG_ORIG(MSG_FMT_WORDVALNL),
294 			    EC_WORD(shdr->sh_info));
295 			break;
296 
297 		case SHDR_CMD_T_SH_LINK:
298 			elfedit_printf(MSG_ORIG(MSG_FMT_WORDVALNL),
299 			    EC_WORD(shdr->sh_link));
300 			break;
301 
302 		case SHDR_CMD_T_SH_NAME:
303 			/*
304 			 * In simple output mode, we show the string. In
305 			 * numeric mode, we show the string table offset.
306 			 */
307 			if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
308 				elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
309 				    sec->sec_name);
310 			} else {
311 				elfedit_printf(MSG_ORIG(MSG_FMT_WORDVALNL),
312 				    EC_WORD(shdr->sh_name));
313 			}
314 			break;
315 
316 		case SHDR_CMD_T_SH_OFFSET:
317 			elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
318 			    EC_XWORD(shdr->sh_offset));
319 			break;
320 
321 		case SHDR_CMD_T_SH_SIZE:
322 			elfedit_printf(MSG_ORIG(MSG_FMT_XWORDHEXNL),
323 			    EC_XWORD(shdr->sh_size));
324 			break;
325 
326 		case SHDR_CMD_T_SH_TYPE:
327 			if (outstyle == ELFEDIT_OUTSTYLE_SIMPLE) {
328 				Conv_inv_buf_t inv_buf;
329 
330 				elfedit_printf(MSG_ORIG(MSG_FMT_STRNL),
331 				    conv_sec_type(osabi, mach, shdr->sh_type, 0,
332 				    &inv_buf));
333 			} else {
334 				elfedit_printf(MSG_ORIG(MSG_FMT_WORDHEXNL),
335 				    EC_WORD(shdr->sh_type));
336 			}
337 			break;
338 		}
339 	}
340 }
341 
342 
343 /*
344  * Common body for the shdr: module commands. These commands
345  * share a large amount of common behavior, so it is convenient
346  * to centralize things and use the cmd argument to handle the
347  * small differences.
348  *
349  * entry:
350  *	cmd - One of the SHDR_CMD_T_* constants listed above, specifying
351  *		which command to implement.
352  *	obj_state, argc, argv - Standard command arguments
353  */
354 static elfedit_cmdret_t
355 cmd_body(SHDR_CMD_T cmd, elfedit_obj_state_t *obj_state,
356     int argc, const char *argv[])
357 {
358 	Ehdr			*ehdr = obj_state->os_ehdr;
359 	uchar_t			osabi = ehdr->e_ident[EI_OSABI];
360 	Half			mach = ehdr->e_machine;
361 	ARGSTATE		argstate;
362 	Word			ndx;
363 	elfedit_section_t	*shdr_sec;
364 	Shdr			*shdr;
365 	elfedit_cmdret_t	ret = ELFEDIT_CMDRET_NONE;
366 	PRINT_SHDR_T		print_type;
367 
368 	process_args(obj_state, argc, argv, cmd, &argstate);
369 
370 	/* If there are no arguments, dump the whole table and return */
371 	if (argstate.argc == 0) {
372 		print_shdr(cmd, 0, &argstate, 0, obj_state->os_shnum,
373 		    PRINT_SHDR_ALL);
374 		return (ELFEDIT_CMDRET_NONE);
375 	}
376 
377 	/*
378 	 * The first argument gives the section to use. This can be a
379 	 * name (default), section index, or section type, depending on
380 	 * the options used.
381 	 */
382 	if (argstate.optmask & SHDR_OPT_F_SHNDX) {
383 		ndx = elfedit_atoshndx(argstate.argv[0], obj_state->os_shnum);
384 		print_type = PRINT_SHDR_ALL;
385 	} else if (argstate.optmask & SHDR_OPT_F_SHTYP) {
386 		ndx = elfedit_type_to_shndx(obj_state,
387 		    elfedit_atoconst(argstate.argv[0], ELFEDIT_CONST_SHT));
388 		print_type = PRINT_SHDR_TYPE;
389 	} else {
390 		ndx = elfedit_name_to_shndx(obj_state, argstate.argv[0]);
391 		print_type = PRINT_SHDR_NAME;
392 	}
393 
394 	/* If there is a single argument, display that item and return */
395 	if (argstate.argc == 1) {
396 		Word	cnt;
397 
398 		cnt = (print_type == PRINT_SHDR_ALL) ?
399 		    1 : obj_state->os_shnum - ndx;
400 		print_shdr(cmd, 0, &argstate, ndx, cnt, print_type);
401 		return (ELFEDIT_CMDRET_NONE);
402 	}
403 
404 	/*
405 	 * Section [0] is supposed to be all zero unless extended sections
406 	 * are in force. Rather than setting extended values directly,
407 	 * it is expected to be handled by libelf. So, a direct change here
408 	 * is probably not what was intended.
409 	 */
410 	if (ndx == 0)
411 		elfedit_msg(ELFEDIT_MSG_DEBUG, MSG_INTL(MSG_DEBUG_CHGSHDR0));
412 
413 	/* The second value is an integer giving a new value */
414 	shdr_sec = &obj_state->os_secarr[ndx];
415 	shdr = shdr_sec->sec_shdr;
416 	switch (cmd) {
417 		/*
418 		 * SHDR_CMD_T_DUMP can't get here: It never has more than
419 		 * one argument, and is handled above.
420 		 */
421 
422 	case SHDR_CMD_T_SH_ADDR:
423 		{
424 			Addr sh_addr = elfedit_atoui(argstate.argv[1], NULL);
425 
426 			if (shdr->sh_addr == sh_addr) {
427 				elfedit_msg(ELFEDIT_MSG_DEBUG,
428 				    MSG_INTL(MSG_DEBUG_LLX_OK),
429 				    ndx, shdr_sec->sec_name,
430 				    MSG_ORIG(MSG_CMD_SH_ADDR),
431 				    EC_ADDR(shdr->sh_addr));
432 			} else {
433 				elfedit_msg(ELFEDIT_MSG_DEBUG,
434 				    MSG_INTL(MSG_DEBUG_LLX_CHG),
435 				    ndx, shdr_sec->sec_name,
436 				    MSG_ORIG(MSG_CMD_SH_ADDR),
437 				    EC_ADDR(shdr->sh_addr), EC_ADDR(sh_addr));
438 				ret = ELFEDIT_CMDRET_MOD;
439 				shdr->sh_addr = sh_addr;
440 			}
441 		}
442 		break;
443 
444 	case SHDR_CMD_T_SH_ADDRALIGN:
445 		{
446 			Xword	sh_addralign;
447 
448 			sh_addralign = elfedit_atoui(argstate.argv[1], NULL);
449 			if (elfedit_bits_set(sh_addralign,
450 			    sizeof (sh_addralign)) > 1)
451 				elfedit_msg(ELFEDIT_MSG_DEBUG,
452 				    MSG_INTL(MSG_DEBUG_ADDRALIGN),
453 				    argstate.argv[1]);
454 			if (shdr->sh_addralign == sh_addralign) {
455 				elfedit_msg(ELFEDIT_MSG_DEBUG,
456 				    MSG_INTL(MSG_DEBUG_LLX_OK),
457 				    ndx, shdr_sec->sec_name,
458 				    MSG_ORIG(MSG_CMD_SH_ADDRALIGN),
459 				    EC_XWORD(shdr->sh_addralign));
460 			} else {
461 				elfedit_msg(ELFEDIT_MSG_DEBUG,
462 				    MSG_INTL(MSG_DEBUG_LLX_CHG),
463 				    ndx, shdr_sec->sec_name,
464 				    MSG_ORIG(MSG_CMD_SH_ADDRALIGN),
465 				    EC_XWORD(shdr->sh_addralign),
466 				    EC_XWORD(sh_addralign));
467 				ret = ELFEDIT_CMDRET_MOD;
468 				shdr->sh_addralign = sh_addralign;
469 			}
470 		}
471 		break;
472 
473 	case SHDR_CMD_T_SH_ENTSIZE:
474 		{
475 			Xword sh_entsize;
476 
477 			sh_entsize = elfedit_atoui(argstate.argv[1], NULL);
478 			if (shdr->sh_entsize == sh_entsize) {
479 				elfedit_msg(ELFEDIT_MSG_DEBUG,
480 				    MSG_INTL(MSG_DEBUG_LLX_OK),
481 				    ndx, shdr_sec->sec_name,
482 				    MSG_ORIG(MSG_CMD_SH_ENTSIZE),
483 				    EC_XWORD(shdr->sh_entsize));
484 			} else {
485 				elfedit_msg(ELFEDIT_MSG_DEBUG,
486 				    MSG_INTL(MSG_DEBUG_LLX_CHG),
487 				    ndx, shdr_sec->sec_name,
488 				    MSG_ORIG(MSG_CMD_SH_ENTSIZE),
489 				    EC_XWORD(shdr->sh_entsize),
490 				    EC_XWORD(sh_entsize));
491 				ret = ELFEDIT_CMDRET_MOD;
492 				shdr->sh_entsize = sh_entsize;
493 			}
494 		}
495 		break;
496 
497 	case SHDR_CMD_T_SH_FLAGS:
498 		{
499 			Conv_sec_flags_buf_t buf1, buf2;
500 			Word	sh_flags = 0;
501 			int	i;
502 
503 						/* Collect the flag arguments */
504 			for (i = 1; i < argstate.argc; i++)
505 				sh_flags |=
506 				    (Word) elfedit_atoconst(argstate.argv[i],
507 				    ELFEDIT_CONST_SHF);
508 
509 			/* Complement the value? */
510 			if (argstate.optmask & SHDR_OPT_F_CMP)
511 				sh_flags = ~sh_flags;
512 
513 			/* Perform any requested bit operations */
514 			if (argstate.optmask & SHDR_OPT_F_AND)
515 				sh_flags &= shdr->sh_flags;
516 			else if (argstate.optmask & SHDR_OPT_F_OR)
517 				sh_flags |= shdr->sh_flags;
518 
519 			/* Set the value */
520 			if (shdr->sh_flags == sh_flags) {
521 				elfedit_msg(ELFEDIT_MSG_DEBUG,
522 				    MSG_INTL(MSG_DEBUG_S_OK),
523 				    ndx, shdr_sec->sec_name,
524 				    MSG_ORIG(MSG_CMD_SH_FLAGS),
525 				    conv_sec_flags(osabi, mach,
526 				    shdr->sh_flags, 0, &buf1));
527 			} else {
528 				elfedit_msg(ELFEDIT_MSG_DEBUG,
529 				    MSG_INTL(MSG_DEBUG_S_CHG),
530 				    ndx, shdr_sec->sec_name,
531 				    MSG_ORIG(MSG_CMD_SH_FLAGS),
532 				    conv_sec_flags(osabi, mach,
533 				    shdr->sh_flags, 0, &buf1),
534 				    conv_sec_flags(osabi, mach,
535 				    sh_flags, 0, &buf2));
536 				ret = ELFEDIT_CMDRET_MOD;
537 				shdr->sh_flags = sh_flags;
538 			}
539 		}
540 		break;
541 
542 	case SHDR_CMD_T_SH_INFO:
543 		{
544 			Word sh_info;
545 
546 			if (argstate.optmask & SHDR_OPT_F_VALUE_SHNAM)
547 				sh_info = elfedit_name_to_shndx(obj_state,
548 				    argstate.argv[1]);
549 			else if (argstate.optmask & SHDR_OPT_F_VALUE_SHTYP)
550 				sh_info = elfedit_type_to_shndx(obj_state,
551 				    elfedit_atoconst(argstate.argv[1],
552 				    ELFEDIT_CONST_SHT));
553 			else
554 				sh_info = elfedit_atoui(argstate.argv[1], NULL);
555 
556 			if (shdr->sh_info == sh_info) {
557 				elfedit_msg(ELFEDIT_MSG_DEBUG,
558 				    MSG_INTL(MSG_DEBUG_D_OK),
559 				    ndx, shdr_sec->sec_name,
560 				    MSG_ORIG(MSG_CMD_SH_INFO),
561 				    EC_WORD(shdr->sh_info));
562 			} else {
563 				elfedit_msg(ELFEDIT_MSG_DEBUG,
564 				    MSG_INTL(MSG_DEBUG_D_CHG),
565 				    ndx, shdr_sec->sec_name,
566 				    MSG_ORIG(MSG_CMD_SH_INFO),
567 				    EC_WORD(shdr->sh_info), EC_WORD(sh_info));
568 				ret = ELFEDIT_CMDRET_MOD;
569 				shdr->sh_info = sh_info;
570 			}
571 		}
572 		break;
573 
574 	case SHDR_CMD_T_SH_LINK:
575 		{
576 			Word sh_link;
577 
578 			if (argstate.optmask & SHDR_OPT_F_VALUE_SHNAM)
579 				sh_link = elfedit_name_to_shndx(obj_state,
580 				    argstate.argv[1]);
581 			else if (argstate.optmask & SHDR_OPT_F_VALUE_SHTYP)
582 				sh_link = elfedit_type_to_shndx(obj_state,
583 				    elfedit_atoconst(argstate.argv[1],
584 				    ELFEDIT_CONST_SHT));
585 			else
586 				sh_link = elfedit_atoui(argstate.argv[1], NULL);
587 
588 			if (shdr->sh_link == sh_link) {
589 				elfedit_msg(ELFEDIT_MSG_DEBUG,
590 				    MSG_INTL(MSG_DEBUG_D_OK),
591 				    ndx, shdr_sec->sec_name,
592 				    MSG_ORIG(MSG_CMD_SH_LINK),
593 				    EC_WORD(shdr->sh_link));
594 			} else {
595 				elfedit_msg(ELFEDIT_MSG_DEBUG,
596 				    MSG_INTL(MSG_DEBUG_D_CHG),
597 				    ndx, shdr_sec->sec_name,
598 				    MSG_ORIG(MSG_CMD_SH_LINK),
599 				    EC_WORD(shdr->sh_link), EC_WORD(sh_link));
600 				ret = ELFEDIT_CMDRET_MOD;
601 				shdr->sh_link = sh_link;
602 			}
603 		}
604 		break;
605 
606 	case SHDR_CMD_T_SH_NAME:
607 		{
608 			elfedit_section_t *shstr_sec =
609 			    &obj_state->os_secarr[obj_state->os_shstrndx];
610 			Word sh_name;
611 
612 			/*
613 			 * If -name_offset was specified, this is an offset
614 			 * into the string table. Otherwise it is a string
615 			 * we need to turn into an offset.
616 			 */
617 			sh_name = (argstate.optmask & SHDR_OPT_F_NAMOFFSET) ?
618 			    elfedit_atoui(argstate.argv[1], NULL) :
619 			    elfedit_strtab_insert(obj_state,
620 			    shstr_sec, NULL, argstate.argv[1]);
621 			if (shdr->sh_name == sh_name) {
622 				elfedit_msg(ELFEDIT_MSG_DEBUG,
623 				    MSG_INTL(MSG_DEBUG_D_OK),
624 				    ndx, shdr_sec->sec_name,
625 				    MSG_ORIG(MSG_CMD_SH_NAME),
626 				    EC_WORD(shdr->sh_name));
627 			} else {
628 				/*
629 				 * The section name is cached, so we must
630 				 * also update that value. This call will
631 				 * warn if the offset is out of range, and
632 				 * will supply a safe string in that case.
633 				 */
634 				shdr_sec->sec_name =
635 				    elfedit_offset_to_str(shstr_sec,
636 				    sh_name, ELFEDIT_MSG_DEBUG, 1);
637 
638 				elfedit_msg(ELFEDIT_MSG_DEBUG,
639 				    MSG_INTL(MSG_DEBUG_D_CHG),
640 				    ndx, shdr_sec->sec_name,
641 				    MSG_ORIG(MSG_CMD_SH_NAME),
642 				    EC_WORD(shdr->sh_name), EC_WORD(sh_name));
643 				ret = ELFEDIT_CMDRET_MOD;
644 				shdr->sh_name = sh_name;
645 			}
646 		}
647 		break;
648 
649 	case SHDR_CMD_T_SH_OFFSET:
650 		{
651 			Off sh_offset;
652 
653 			sh_offset = elfedit_atoui(argstate.argv[1], NULL);
654 			if (shdr->sh_offset == sh_offset) {
655 				elfedit_msg(ELFEDIT_MSG_DEBUG,
656 				    MSG_INTL(MSG_DEBUG_LLX_OK),
657 				    ndx, shdr_sec->sec_name,
658 				    MSG_ORIG(MSG_CMD_SH_OFFSET),
659 				    EC_XWORD(shdr->sh_offset));
660 			} else {
661 				elfedit_msg(ELFEDIT_MSG_DEBUG,
662 				    MSG_INTL(MSG_DEBUG_LLX_CHG),
663 				    ndx, shdr_sec->sec_name,
664 				    MSG_ORIG(MSG_CMD_SH_OFFSET),
665 				    EC_XWORD(shdr->sh_offset),
666 				    EC_XWORD(sh_offset));
667 				ret = ELFEDIT_CMDRET_MOD;
668 				shdr->sh_offset = sh_offset;
669 			}
670 		}
671 		break;
672 
673 	case SHDR_CMD_T_SH_SIZE:
674 		{
675 			Xword sh_size;
676 
677 			sh_size = elfedit_atoui(argstate.argv[1], NULL);
678 			if (shdr->sh_size == sh_size) {
679 				elfedit_msg(ELFEDIT_MSG_DEBUG,
680 				    MSG_INTL(MSG_DEBUG_LLX_OK),
681 				    ndx, shdr_sec->sec_name,
682 				    MSG_ORIG(MSG_CMD_SH_SIZE),
683 				    EC_XWORD(shdr->sh_size));
684 			} else {
685 				elfedit_msg(ELFEDIT_MSG_DEBUG,
686 				    MSG_INTL(MSG_DEBUG_LLX_CHG),
687 				    ndx, shdr_sec->sec_name,
688 				    MSG_ORIG(MSG_CMD_SH_SIZE),
689 				    EC_XWORD(shdr->sh_size),
690 				    EC_XWORD(sh_size));
691 				ret = ELFEDIT_CMDRET_MOD;
692 				shdr->sh_size = sh_size;
693 			}
694 		}
695 		break;
696 
697 	case SHDR_CMD_T_SH_TYPE:
698 		{
699 			Word sh_type = elfedit_atoconst(argstate.argv[1],
700 			    ELFEDIT_CONST_SHT);
701 			Conv_inv_buf_t inv_buf1, inv_buf2;
702 
703 			if (shdr->sh_type == sh_type) {
704 				elfedit_msg(ELFEDIT_MSG_DEBUG,
705 				    MSG_INTL(MSG_DEBUG_S_OK),
706 				    ndx, shdr_sec->sec_name,
707 				    MSG_ORIG(MSG_CMD_SH_TYPE),
708 				    conv_sec_type(osabi, mach, shdr->sh_type,
709 				    0, &inv_buf1));
710 			} else {
711 				elfedit_msg(ELFEDIT_MSG_DEBUG,
712 				    MSG_INTL(MSG_DEBUG_S_CHG),
713 				    ndx, shdr_sec->sec_name,
714 				    MSG_ORIG(MSG_CMD_SH_TYPE),
715 				    conv_sec_type(osabi, mach, shdr->sh_type,
716 				    0, &inv_buf1),
717 				    conv_sec_type(osabi, mach, sh_type,
718 				    0, &inv_buf2));
719 				ret = ELFEDIT_CMDRET_MOD;
720 				shdr->sh_type = sh_type;
721 			}
722 		}
723 		break;
724 	}
725 
726 	/*
727 	 * If we modified the section header array, tell libelf.
728 	 */
729 	if (ret == ELFEDIT_CMDRET_MOD)
730 		elfedit_modified_shdr(shdr_sec);
731 
732 	/* Do autoprint */
733 	print_shdr(cmd, 1, &argstate, ndx, 1, PRINT_SHDR_ALL);
734 
735 	return (ret);
736 }
737 
738 
739 
740 
741 /*
742  * Command completion functions for the various commands
743  */
744 
745 /*
746  * All of the commands accept the same first argument (sec) that
747  * specifies the section. This argument can be a section name
748  * (default), section index, or section type, depending on the
749  * options used. This routine determines which case is current,
750  * and then supplies completion for the first argument.
751  */
752 static void
753 cpl_1starg_sec(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
754     const char *argv[], int num_opt)
755 {
756 	elfedit_section_t *sec;
757 	enum { NAME, INDEX, TYPE } op;
758 	Word ndx;
759 
760 	if (argc != (num_opt + 1))
761 		return;
762 
763 	op = NAME;
764 	for (ndx = 0; ndx < num_opt; ndx++) {
765 		if (strcmp(argv[ndx], MSG_ORIG(MSG_STR_MINUS_SHNDX)) == 0)
766 			op = INDEX;
767 		else if (strcmp(argv[ndx], MSG_ORIG(MSG_STR_MINUS_SHTYP)) == 0)
768 			op = TYPE;
769 	}
770 
771 	switch (op) {
772 	case NAME:
773 		if (obj_state == NULL)
774 			break;
775 		sec = obj_state->os_secarr;
776 		for (ndx = 0; ndx < obj_state->os_shnum; ndx++, sec++)
777 			elfedit_cpl_match(cpldata, sec->sec_name, 0);
778 		break;
779 
780 	case INDEX:
781 		elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHN);
782 		break;
783 
784 	case TYPE:
785 		elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHT);
786 		break;
787 	}
788 }
789 
790 
791 /*ARGSUSED*/
792 static void
793 cpl_sh_flags(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
794     const char *argv[], int num_opt)
795 {
796 	/* Handle -shXXX options */
797 	cpl_1starg_sec(obj_state, cpldata, argc, argv, num_opt);
798 
799 	/* The second and following arguments can be an SHF_ value */
800 	if (argc >= (num_opt + 2))
801 		elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHF);
802 }
803 
804 /*
805  * For shdr:sh_info and shdr:sh_link: The value argument can be an
806  * integer, section name, or section type.
807  */
808 /*ARGSUSED*/
809 static void
810 cpl_sh_infolink(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
811     const char *argv[], int num_opt)
812 {
813 	elfedit_section_t *sec;
814 	enum { NAME, INTVAL, TYPE } op;
815 	Word ndx;
816 
817 	/* Handle -shXXX options */
818 	cpl_1starg_sec(obj_state, cpldata, argc, argv, num_opt);
819 
820 	if (argc != (num_opt + 2))
821 		return;
822 
823 	op = INTVAL;
824 	for (ndx = 0; ndx < num_opt; ndx++) {
825 		if (strcmp(argv[ndx], MSG_ORIG(MSG_STR_MINUS_VALUE_SHNAM)) == 0)
826 			op = NAME;
827 		else if (strcmp(argv[ndx],
828 		    MSG_ORIG(MSG_STR_MINUS_VALUE_SHTYP)) == 0)
829 			op = TYPE;
830 	}
831 
832 	switch (op) {
833 	case NAME:
834 		if (obj_state == NULL)
835 			break;
836 		sec = obj_state->os_secarr;
837 		for (ndx = 0; ndx < obj_state->os_shnum; ndx++, sec++)
838 			elfedit_cpl_match(cpldata, sec->sec_name, 0);
839 		break;
840 
841 	case TYPE:
842 		elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHT);
843 		break;
844 	}
845 }
846 
847 /*ARGSUSED*/
848 static void
849 cpl_sh_type(elfedit_obj_state_t *obj_state, void *cpldata, int argc,
850     const char *argv[], int num_opt)
851 {
852 	/* Handle -shXXX options */
853 	cpl_1starg_sec(obj_state, cpldata, argc, argv, num_opt);
854 
855 	/* The second argument can be an SHT_ value */
856 	if (argc == (num_opt + 2))
857 		elfedit_cpl_atoconst(cpldata, ELFEDIT_CONST_SHT);
858 }
859 
860 
861 
862 /*
863  * Implementation functions for the commands
864  */
865 static elfedit_cmdret_t
866 cmd_dump(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
867 {
868 	return (cmd_body(SHDR_CMD_T_DUMP, obj_state, argc, argv));
869 }
870 
871 
872 static elfedit_cmdret_t
873 cmd_sh_addr(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
874 {
875 	return (cmd_body(SHDR_CMD_T_SH_ADDR, obj_state, argc, argv));
876 }
877 
878 
879 static elfedit_cmdret_t
880 cmd_sh_addralign(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
881 {
882 	return (cmd_body(SHDR_CMD_T_SH_ADDRALIGN, obj_state, argc, argv));
883 }
884 
885 
886 static elfedit_cmdret_t
887 cmd_sh_entsize(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
888 {
889 	return (cmd_body(SHDR_CMD_T_SH_ENTSIZE, obj_state, argc, argv));
890 }
891 
892 static elfedit_cmdret_t
893 cmd_sh_flags(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
894 {
895 	return (cmd_body(SHDR_CMD_T_SH_FLAGS, obj_state, argc, argv));
896 }
897 
898 static elfedit_cmdret_t
899 cmd_sh_info(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
900 {
901 	return (cmd_body(SHDR_CMD_T_SH_INFO, obj_state, argc, argv));
902 }
903 
904 static elfedit_cmdret_t
905 cmd_sh_link(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
906 {
907 	return (cmd_body(SHDR_CMD_T_SH_LINK, obj_state, argc, argv));
908 }
909 
910 static elfedit_cmdret_t
911 cmd_sh_name(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
912 {
913 	return (cmd_body(SHDR_CMD_T_SH_NAME, obj_state, argc, argv));
914 }
915 
916 static elfedit_cmdret_t
917 cmd_sh_offset(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
918 {
919 	return (cmd_body(SHDR_CMD_T_SH_OFFSET, obj_state, argc, argv));
920 }
921 
922 static elfedit_cmdret_t
923 cmd_sh_size(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
924 {
925 	return (cmd_body(SHDR_CMD_T_SH_SIZE, obj_state, argc, argv));
926 }
927 
928 static elfedit_cmdret_t
929 cmd_sh_type(elfedit_obj_state_t *obj_state, int argc, const char *argv[])
930 {
931 	return (cmd_body(SHDR_CMD_T_SH_TYPE, obj_state, argc, argv));
932 }
933 
934 
935 
936 /*ARGSUSED*/
937 elfedit_module_t *
938 elfedit_init(elfedit_module_version_t version)
939 {
940 	/* Multiple commands accept only the standard set of options */
941 	static elfedit_cmd_optarg_t opt_std[] = {
942 		{ ELFEDIT_STDOA_OPT_O, NULL,
943 		    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
944 		{ MSG_ORIG(MSG_STR_MINUS_SHNDX),
945 		    /* MSG_INTL(MSG_OPTDESC_SHNDX) */
946 		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
947 		    SHDR_OPT_F_SHNDX, SHDR_OPT_F_SHTYP },
948 		{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
949 		    /* MSG_INTL(MSG_OPTDESC_SHTYP) */
950 		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
951 		    SHDR_OPT_F_SHTYP, SHDR_OPT_F_SHNDX },
952 		{ NULL }
953 	};
954 
955 	/*
956 	 * sh_info and sh_link accept the standard options above,
957 	 * plus -value_shnam and -value_shtyp.
958 	 */
959 	static elfedit_cmd_optarg_t opt_infolink[] = {
960 		{ ELFEDIT_STDOA_OPT_O, NULL,
961 		    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
962 		{ MSG_ORIG(MSG_STR_MINUS_SHNDX),
963 		    /* MSG_INTL(MSG_OPTDESC_SHNDX) */
964 		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
965 		    SHDR_OPT_F_SHNDX, SHDR_OPT_F_SHTYP },
966 		{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
967 		    /* MSG_INTL(MSG_OPTDESC_SHTYP) */
968 		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
969 		    SHDR_OPT_F_SHTYP, SHDR_OPT_F_SHNDX },
970 		{ MSG_ORIG(MSG_STR_MINUS_VALUE_SHNAM),
971 		    /* MSG_INTL(MSG_OPTDESC_VALUE_SHNAM) */
972 		    ELFEDIT_I18NHDL(MSG_OPTDESC_VALUE_SHNAM), 0,
973 		    SHDR_OPT_F_VALUE_SHNAM, SHDR_OPT_F_VALUE_SHNAM },
974 		{ MSG_ORIG(MSG_STR_MINUS_VALUE_SHTYP),
975 		    /* MSG_INTL(MSG_OPTDESC_VALUE_SHTYP) */
976 		    ELFEDIT_I18NHDL(MSG_OPTDESC_VALUE_SHTYP), 0,
977 		    SHDR_OPT_F_VALUE_SHTYP, SHDR_OPT_F_VALUE_SHTYP },
978 		{ NULL }
979 	};
980 
981 	/* shdr:sh_addr */
982 	static const char *name_sh_addr[] = {
983 	    MSG_ORIG(MSG_CMD_SH_ADDR), NULL };
984 	static elfedit_cmd_optarg_t arg_sh_addr[] = {
985 		{ MSG_ORIG(MSG_STR_SEC),
986 		    /* MSG_INTL(MSG_A1_SEC) */
987 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
988 		    ELFEDIT_CMDOA_F_OPT },
989 		{ MSG_ORIG(MSG_STR_VALUE),
990 		    /* MSG_INTL(MSG_A2_DESC_SH_ADDR) */
991 		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_ADDR),
992 		    ELFEDIT_CMDOA_F_OPT },
993 		{ NULL }
994 	};
995 
996 	/* shdr:dump */
997 	static const char *name_dump[] = {
998 	    MSG_ORIG(MSG_CMD_DUMP),
999 	    MSG_ORIG(MSG_STR_EMPTY),	/* "" makes this the default command */
1000 	    NULL
1001 	};
1002 	static elfedit_cmd_optarg_t opt_dump[] = {
1003 		{ MSG_ORIG(MSG_STR_MINUS_SHNDX),
1004 		    /* MSG_INTL(MSG_OPTDESC_SHNDX) */
1005 		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
1006 		    SHDR_OPT_F_SHNDX, SHDR_OPT_F_SHTYP },
1007 		{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
1008 		    /* MSG_INTL(MSG_OPTDESC_SHTYP) */
1009 		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
1010 		    SHDR_OPT_F_SHTYP, SHDR_OPT_F_SHNDX },
1011 		{ NULL }
1012 	};
1013 	static elfedit_cmd_optarg_t arg_dump[] = {
1014 		{ MSG_ORIG(MSG_STR_SEC),
1015 		    /* MSG_INTL(MSG_A1_SEC) */
1016 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
1017 		    ELFEDIT_CMDOA_F_OPT },
1018 		{ NULL }
1019 	};
1020 
1021 	/* shdr:sh_addralign */
1022 	static const char *name_sh_addralign[] = {
1023 	    MSG_ORIG(MSG_CMD_SH_ADDRALIGN), NULL };
1024 	static elfedit_cmd_optarg_t arg_sh_addralign[] = {
1025 		{ MSG_ORIG(MSG_STR_SEC),
1026 		    /* MSG_INTL(MSG_A1_SEC) */
1027 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
1028 		    ELFEDIT_CMDOA_F_OPT },
1029 		{ MSG_ORIG(MSG_STR_VALUE),
1030 		    /* MSG_INTL(MSG_A2_DESC_SH_ADDRALIGN) */
1031 		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_ADDRALIGN),
1032 		    ELFEDIT_CMDOA_F_OPT },
1033 		{ NULL }
1034 	};
1035 
1036 	/* shdr:sh_entsize */
1037 	static const char *name_sh_entsize[] = {
1038 	    MSG_ORIG(MSG_CMD_SH_ENTSIZE), NULL };
1039 	static elfedit_cmd_optarg_t arg_sh_entsize[] = {
1040 		{ MSG_ORIG(MSG_STR_SEC),
1041 		    /* MSG_INTL(MSG_A1_SEC) */
1042 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
1043 		    ELFEDIT_CMDOA_F_OPT },
1044 		{ MSG_ORIG(MSG_STR_VALUE),
1045 		    /* MSG_INTL(MSG_A2_DESC_SH_ENTSIZE) */
1046 		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_ENTSIZE),
1047 		    ELFEDIT_CMDOA_F_OPT },
1048 		{ NULL }
1049 	};
1050 
1051 	/* shdr:sh_flags */
1052 	static const char *name_sh_flags[] = {
1053 	    MSG_ORIG(MSG_CMD_SH_FLAGS), NULL };
1054 	static elfedit_cmd_optarg_t opt_sh_flags[] = {
1055 		{ ELFEDIT_STDOA_OPT_AND, NULL,
1056 		    ELFEDIT_CMDOA_F_INHERIT, SHDR_OPT_F_AND, SHDR_OPT_F_OR },
1057 		{ ELFEDIT_STDOA_OPT_CMP, NULL,
1058 		    ELFEDIT_CMDOA_F_INHERIT, SHDR_OPT_F_CMP, 0 },
1059 		{ ELFEDIT_STDOA_OPT_O, NULL,
1060 		    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
1061 		{ ELFEDIT_STDOA_OPT_OR, NULL,
1062 		    ELFEDIT_CMDOA_F_INHERIT, SHDR_OPT_F_OR, SHDR_OPT_F_AND },
1063 		{ MSG_ORIG(MSG_STR_MINUS_SHNDX),
1064 		    /* MSG_INTL(MSG_OPTDESC_SHNDX) */
1065 		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
1066 		    SHDR_OPT_F_SHNDX, SHDR_OPT_F_SHTYP },
1067 		{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
1068 		    /* MSG_INTL(MSG_OPTDESC_SHTYP) */
1069 		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
1070 		    SHDR_OPT_F_SHTYP, SHDR_OPT_F_SHNDX },
1071 		{ NULL }
1072 	};
1073 	static elfedit_cmd_optarg_t arg_sh_flags[] = {
1074 		{ MSG_ORIG(MSG_STR_SEC),
1075 		    /* MSG_INTL(MSG_A1_SEC) */
1076 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
1077 		    ELFEDIT_CMDOA_F_OPT },
1078 		{ MSG_ORIG(MSG_STR_VALUE),
1079 		    /* MSG_INTL(MSG_A2_DESC_SH_FLAGS) */
1080 		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_FLAGS),
1081 		    ELFEDIT_CMDOA_F_OPT | ELFEDIT_CMDOA_F_MULT },
1082 		{ NULL }
1083 	};
1084 
1085 	/* shdr:sh_info */
1086 	static const char *name_sh_info[] = {
1087 	    MSG_ORIG(MSG_CMD_SH_INFO), NULL };
1088 	static elfedit_cmd_optarg_t arg_sh_info[] = {
1089 		{ MSG_ORIG(MSG_STR_SEC),
1090 		    /* MSG_INTL(MSG_A1_SEC) */
1091 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
1092 		    ELFEDIT_CMDOA_F_OPT },
1093 		{ MSG_ORIG(MSG_STR_VALUE),
1094 		    /* MSG_INTL(MSG_A2_DESC_SH_INFO) */
1095 		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_INFO),
1096 		    ELFEDIT_CMDOA_F_OPT },
1097 		{ NULL }
1098 	};
1099 
1100 	/* shdr:sh_link */
1101 	static const char *name_sh_link[] = {
1102 	    MSG_ORIG(MSG_CMD_SH_LINK), NULL };
1103 	static elfedit_cmd_optarg_t arg_sh_link[] = {
1104 		{ MSG_ORIG(MSG_STR_SEC),
1105 		    /* MSG_INTL(MSG_A1_SEC) */
1106 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
1107 		    ELFEDIT_CMDOA_F_OPT },
1108 		{ MSG_ORIG(MSG_STR_VALUE),
1109 		    /* MSG_INTL(MSG_A2_DESC_SH_LINK) */
1110 		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_LINK),
1111 		    ELFEDIT_CMDOA_F_OPT },
1112 		{ NULL }
1113 	};
1114 
1115 	/* shdr:sh_name */
1116 	static const char *name_sh_name[] = {
1117 	    MSG_ORIG(MSG_CMD_SH_NAME), NULL };
1118 	static elfedit_cmd_optarg_t opt_sh_name[] = {
1119 		{ MSG_ORIG(MSG_STR_MINUS_NAME_OFFSET),
1120 		    /* MSG_INTL(MSG_OPTDESC_NAME_OFFSET) */
1121 		    ELFEDIT_I18NHDL(MSG_OPTDESC_NAME_OFFSET), 0,
1122 		    SHDR_OPT_F_NAMOFFSET, 0 },
1123 		{ ELFEDIT_STDOA_OPT_O, NULL,
1124 		    ELFEDIT_CMDOA_F_INHERIT, 0, 0 },
1125 		{ MSG_ORIG(MSG_STR_MINUS_SHNDX),
1126 		    /* MSG_INTL(MSG_OPTDESC_SHNDX) */
1127 		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHNDX), 0,
1128 		    SHDR_OPT_F_SHNDX, SHDR_OPT_F_SHTYP },
1129 		{ MSG_ORIG(MSG_STR_MINUS_SHTYP),
1130 		    /* MSG_INTL(MSG_OPTDESC_SHTYP) */
1131 		    ELFEDIT_I18NHDL(MSG_OPTDESC_SHTYP), 0,
1132 		    SHDR_OPT_F_SHTYP, SHDR_OPT_F_SHNDX },
1133 		{ NULL }
1134 	};
1135 	static elfedit_cmd_optarg_t arg_sh_name[] = {
1136 		{ MSG_ORIG(MSG_STR_SEC),
1137 		    /* MSG_INTL(MSG_A1_SEC) */
1138 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
1139 		    ELFEDIT_CMDOA_F_OPT },
1140 		{ MSG_ORIG(MSG_STR_NAME),
1141 		    /* MSG_INTL(MSG_A2_DESC_SH_NAME) */
1142 		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_NAME),
1143 		    ELFEDIT_CMDOA_F_OPT },
1144 		{ NULL }
1145 	};
1146 
1147 	/* shdr:sh_offset */
1148 	static const char *name_sh_offset[] = {
1149 	    MSG_ORIG(MSG_CMD_SH_OFFSET), NULL };
1150 	static elfedit_cmd_optarg_t arg_sh_offset[] = {
1151 		{ MSG_ORIG(MSG_STR_SEC),
1152 		    /* MSG_INTL(MSG_A1_SEC) */
1153 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
1154 		    ELFEDIT_CMDOA_F_OPT },
1155 		{ MSG_ORIG(MSG_STR_VALUE),
1156 		    /* MSG_INTL(MSG_A2_DESC_SH_OFFSET) */
1157 		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_OFFSET),
1158 		    ELFEDIT_CMDOA_F_OPT },
1159 		{ NULL }
1160 	};
1161 
1162 	/* shdr:sh_size */
1163 	static const char *name_sh_size[] = {
1164 	    MSG_ORIG(MSG_CMD_SH_SIZE), NULL };
1165 	static elfedit_cmd_optarg_t arg_sh_size[] = {
1166 		{ MSG_ORIG(MSG_STR_SEC),
1167 		    /* MSG_INTL(MSG_A1_SEC) */
1168 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
1169 		    ELFEDIT_CMDOA_F_OPT },
1170 		{ MSG_ORIG(MSG_STR_VALUE),
1171 		    /* MSG_INTL(MSG_A2_DESC_SH_SIZE) */
1172 		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_SIZE),
1173 		    ELFEDIT_CMDOA_F_OPT },
1174 		{ NULL }
1175 	};
1176 
1177 	/* shdr:sh_type */
1178 	static const char *name_sh_type[] = {
1179 	    MSG_ORIG(MSG_CMD_SH_TYPE), NULL };
1180 	static elfedit_cmd_optarg_t arg_sh_type[] = {
1181 		{ MSG_ORIG(MSG_STR_SEC),
1182 		    /* MSG_INTL(MSG_A1_SEC) */
1183 		    ELFEDIT_I18NHDL(MSG_A1_SEC),
1184 		    ELFEDIT_CMDOA_F_OPT },
1185 		{ MSG_ORIG(MSG_STR_VALUE),
1186 		    /* MSG_INTL(MSG_A2_DESC_SH_TYPE) */
1187 		    ELFEDIT_I18NHDL(MSG_A2_DESC_SH_TYPE),
1188 		    ELFEDIT_CMDOA_F_OPT },
1189 		{ NULL }
1190 	};
1191 
1192 	static elfedit_cmd_t cmds[] = {
1193 		/* shdr:dump */
1194 		{ cmd_dump, cpl_1starg_sec, name_dump,
1195 		    /* MSG_INTL(MSG_DESC_DUMP) */
1196 		    ELFEDIT_I18NHDL(MSG_DESC_DUMP),
1197 		    /* MSG_INTL(MSG_HELP_DUMP) */
1198 		    ELFEDIT_I18NHDL(MSG_HELP_DUMP),
1199 		    opt_dump, arg_dump },
1200 
1201 		/* shdr:sh_addr */
1202 		{ cmd_sh_addr, cpl_1starg_sec, name_sh_addr,
1203 		    /* MSG_INTL(MSG_DESC_SH_ADDR) */
1204 		    ELFEDIT_I18NHDL(MSG_DESC_SH_ADDR),
1205 		    /* MSG_INTL(MSG_HELP_SH_ADDR) */
1206 		    ELFEDIT_I18NHDL(MSG_HELP_SH_ADDR),
1207 		    opt_std, arg_sh_addr },
1208 
1209 		/* shdr:sh_addralign */
1210 		{ cmd_sh_addralign, cpl_1starg_sec, name_sh_addralign,
1211 		    /* MSG_INTL(MSG_DESC_SH_ADDRALIGN) */
1212 		    ELFEDIT_I18NHDL(MSG_DESC_SH_ADDRALIGN),
1213 		    /* MSG_INTL(MSG_HELP_SH_ADDRALIGN) */
1214 		    ELFEDIT_I18NHDL(MSG_HELP_SH_ADDRALIGN),
1215 		    opt_std, arg_sh_addralign },
1216 
1217 		/* shdr:sh_entsize */
1218 		{ cmd_sh_entsize, cpl_1starg_sec, name_sh_entsize,
1219 		    /* MSG_INTL(MSG_DESC_SH_ENTSIZE) */
1220 		    ELFEDIT_I18NHDL(MSG_DESC_SH_ENTSIZE),
1221 		    /* MSG_INTL(MSG_HELP_SH_ENTSIZE) */
1222 		    ELFEDIT_I18NHDL(MSG_HELP_SH_ENTSIZE),
1223 		    opt_std, arg_sh_entsize },
1224 
1225 		/* shdr:sh_flags */
1226 		{ cmd_sh_flags, cpl_sh_flags, name_sh_flags,
1227 		    /* MSG_INTL(MSG_DESC_SH_FLAGS) */
1228 		    ELFEDIT_I18NHDL(MSG_DESC_SH_FLAGS),
1229 		    /* MSG_INTL(MSG_HELP_SH_FLAGS) */
1230 		    ELFEDIT_I18NHDL(MSG_HELP_SH_FLAGS),
1231 		    opt_sh_flags, arg_sh_flags },
1232 
1233 		/* shdr:sh_info */
1234 		{ cmd_sh_info, cpl_sh_infolink, name_sh_info,
1235 		    /* MSG_INTL(MSG_DESC_SH_INFO) */
1236 		    ELFEDIT_I18NHDL(MSG_DESC_SH_INFO),
1237 		    /* MSG_INTL(MSG_HELP_SH_INFO) */
1238 		    ELFEDIT_I18NHDL(MSG_HELP_SH_INFO),
1239 		    opt_infolink, arg_sh_info },
1240 
1241 		/* shdr:sh_link */
1242 		{ cmd_sh_link, cpl_sh_infolink, name_sh_link,
1243 		    /* MSG_INTL(MSG_DESC_SH_LINK) */
1244 		    ELFEDIT_I18NHDL(MSG_DESC_SH_LINK),
1245 		    /* MSG_INTL(MSG_HELP_SH_LINK) */
1246 		    ELFEDIT_I18NHDL(MSG_HELP_SH_LINK),
1247 		    opt_infolink, arg_sh_link },
1248 
1249 		/* shdr:sh_name */
1250 		{ cmd_sh_name, cpl_1starg_sec, name_sh_name,
1251 		    /* MSG_INTL(MSG_DESC_SH_NAME) */
1252 		    ELFEDIT_I18NHDL(MSG_DESC_SH_NAME),
1253 		    /* MSG_INTL(MSG_HELP_SH_NAME) */
1254 		    ELFEDIT_I18NHDL(MSG_HELP_SH_NAME),
1255 		    opt_sh_name, arg_sh_name },
1256 
1257 		/* shdr:sh_offset */
1258 		{ cmd_sh_offset, cpl_1starg_sec, name_sh_offset,
1259 		    /* MSG_INTL(MSG_DESC_SH_OFFSET) */
1260 		    ELFEDIT_I18NHDL(MSG_DESC_SH_OFFSET),
1261 		    /* MSG_INTL(MSG_HELP_SH_OFFSET) */
1262 		    ELFEDIT_I18NHDL(MSG_HELP_SH_OFFSET),
1263 		    opt_std, arg_sh_offset },
1264 
1265 		/* shdr:sh_size */
1266 		{ cmd_sh_size, cpl_1starg_sec, name_sh_size,
1267 		    /* MSG_INTL(MSG_DESC_SH_SIZE) */
1268 		    ELFEDIT_I18NHDL(MSG_DESC_SH_SIZE),
1269 		    /* MSG_INTL(MSG_HELP_SH_SIZE) */
1270 		    ELFEDIT_I18NHDL(MSG_HELP_SH_SIZE),
1271 		    opt_std, arg_sh_size },
1272 
1273 		/* shdr:sh_type */
1274 		{ cmd_sh_type, cpl_sh_type, name_sh_type,
1275 		    /* MSG_INTL(MSG_DESC_SH_TYPE) */
1276 		    ELFEDIT_I18NHDL(MSG_DESC_SH_TYPE),
1277 		    /* MSG_INTL(MSG_HELP_SH_TYPE) */
1278 		    ELFEDIT_I18NHDL(MSG_HELP_SH_TYPE),
1279 		    opt_std, arg_sh_type },
1280 
1281 		{ NULL }
1282 	};
1283 
1284 	static elfedit_module_t module = {
1285 	    ELFEDIT_VER_CURRENT, MSG_ORIG(MSG_MOD_NAME),
1286 	    /* MSG_INTL(MSG_MOD_DESC) */
1287 	    ELFEDIT_I18NHDL(MSG_MOD_DESC),
1288 	    cmds, mod_i18nhdl_to_str };
1289 
1290 	return (&module);
1291 }
1292