Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit d59a16836d917548cf41eda3369936684d527f5f

Authored by David Daney 2012-04-25 02:23:14 +0800

Committed by H. Peter Anvin 2012-04-25 02:42:20 +0800

scripts/sortextable: Handle relative entries, and other cleanups

x86 is now using relative rather than absolute addresses in its
exception table, so we add a sorter for these.  If there are
relocations on the __ex_table section, they are redundant and probably
incorrect after the sort, so they are zeroed out leaving them valid
and consistent.

Also use the unaligned safe accessors from tools/{be,le}_byteshift.h

Signed-off-by: David Daney <david.daney@cavium.com>
Link: http://lkml.kernel.org/r/1335291795-26693-2-git-send-email-ddaney.cavm@gmail.com
Signed-off-by: H. Peter Anvin <hpa@zytor.com>

Showing 3 changed files with 164 additions and 88 deletions Inline Diff

scripts/Makefile
scripts/sortextable.c
scripts/sortextable.h

scripts/Makefile

Diff comments View file @ d59a168

 ###
 # scripts contains sources for various helper programs used throughout
 # the kernel for the build process.
 # ---------------------------------------------------------------------------
 # kallsyms:      Find all symbols in vmlinux
 # pnmttologo:    Convert pnm files to logo files
 # conmakehash:   Create chartable
 # conmakehash:	 Create arrays for initializing the kernel console tables
 # docproc:       Used in Documentation/DocBook
 hostprogs-$(CONFIG_KALLSYMS)     += kallsyms
 hostprogs-$(CONFIG_LOGO)         += pnmtologo
 hostprogs-$(CONFIG_VT)           += conmakehash
 hostprogs-$(CONFIG_IKCONFIG)     += bin2c
 hostprogs-$(BUILD_C_RECORDMCOUNT) += recordmcount
 hostprogs-$(CONFIG_BUILDTIME_EXTABLE_SORT) += sortextable
+HOSTCFLAGS_sortextable.o = -I$(srctree)/tools/include
 always		:= $(hostprogs-y) $(hostprogs-m)
 # The following hostprogs-y programs are only build on demand
 hostprogs-y += unifdef docproc
 # These targets are used internally to avoid "is up to date" messages
 PHONY += build_unifdef
 build_unifdef: scripts/unifdef FORCE
 	@:
 build_docproc: scripts/docproc FORCE
 	@:
 subdir-$(CONFIG_MODVERSIONS) += genksyms
 subdir-y                     += mod
 subdir-$(CONFIG_SECURITY_SELINUX) += selinux
 subdir-$(CONFIG_DTC)         += dtc
 # Let clean descend into subdirs
 subdir-	+= basic kconfig package selinux

scripts/sortextable.c

Diff comments View file @ d59a168

1	/*	1	/*
2	* sortextable.c: Sort the kernel's exception table	2	* sortextable.c: Sort the kernel's exception table
3	*	3	*
4	* Copyright 2011 Cavium, Inc.	4	* Copyright 2011 - 2012 Cavium, Inc.
5	*	5	*
6	* Based on code taken from recortmcount.c which is:	6	* Based on code taken from recortmcount.c which is:
7	*	7	*
8	* Copyright 2009 John F. Reiser <jreiser@BitWagon.com>. All rights reserved.	8	* Copyright 2009 John F. Reiser <jreiser@BitWagon.com>. All rights reserved.
9	* Licensed under the GNU General Public License, version 2 (GPLv2).	9	* Licensed under the GNU General Public License, version 2 (GPLv2).
10	*	10	*
11	* Restructured to fit Linux format, as well as other updates:	11	* Restructured to fit Linux format, as well as other updates:
12	* Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.	12	* Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
13	*/	13	*/
14		14
15	/*	15	/*
16	* Strategy: alter the vmlinux file in-place.	16	* Strategy: alter the vmlinux file in-place.
17	*/	17	*/
18		18
19	#include <sys/types.h>	19	#include <sys/types.h>
20	#include <sys/mman.h>	20	#include <sys/mman.h>
21	#include <sys/stat.h>	21	#include <sys/stat.h>
22	#include <getopt.h>	22	#include <getopt.h>
23	#include <elf.h>	23	#include <elf.h>
24	#include <fcntl.h>	24	#include <fcntl.h>
25	#include <setjmp.h>	25	#include <setjmp.h>
26	#include <stdio.h>	26	#include <stdio.h>
27	#include <stdlib.h>	27	#include <stdlib.h>
28	#include <string.h>	28	#include <string.h>
29	#include <unistd.h>	29	#include <unistd.h>
30		30
		31	#include <tools/be_byteshift.h>
		32	#include <tools/le_byteshift.h>
		33
31	static int fd_map; /* File descriptor for file being modified. */	34	static int fd_map; /* File descriptor for file being modified. */
32	static int mmap_failed; /* Boolean flag. */	35	static int mmap_failed; /* Boolean flag. */
33	static void ehdr_curr; / current ElfXX_Ehdr * for resource cleanup */	36	static void ehdr_curr; / current ElfXX_Ehdr * for resource cleanup */
34	static struct stat sb; /* Remember .st_size, etc. */	37	static struct stat sb; /* Remember .st_size, etc. */
35	static jmp_buf jmpenv; /* setjmp/longjmp per-file error escape */	38	static jmp_buf jmpenv; /* setjmp/longjmp per-file error escape */
36		39
37	/* setjmp() return values */	40	/* setjmp() return values */
38	enum {	41	enum {
39	SJ_SETJMP = 0, /* hardwired first return */	42	SJ_SETJMP = 0, /* hardwired first return */
40	SJ_FAIL,	43	SJ_FAIL,
41	SJ_SUCCEED	44	SJ_SUCCEED
42	};	45	};
43		46
44	/* Per-file resource cleanup when multiple files. */	47	/* Per-file resource cleanup when multiple files. */
45	static void	48	static void
46	cleanup(void)	49	cleanup(void)
47	{	50	{
48	if (!mmap_failed)	51	if (!mmap_failed)
49	munmap(ehdr_curr, sb.st_size);	52	munmap(ehdr_curr, sb.st_size);
50	close(fd_map);	53	close(fd_map);
51	}	54	}
52		55
53	static void __attribute__((noreturn))	56	static void __attribute__((noreturn))
54	fail_file(void)	57	fail_file(void)
55	{	58	{
56	cleanup();	59	cleanup();
57	longjmp(jmpenv, SJ_FAIL);	60	longjmp(jmpenv, SJ_FAIL);
58	}	61	}
59		62
60	static void __attribute__((noreturn))	63	static void __attribute__((noreturn))
61	succeed_file(void)	64	succeed_file(void)
62	{	65	{
63	cleanup();	66	cleanup();
64	longjmp(jmpenv, SJ_SUCCEED);	67	longjmp(jmpenv, SJ_SUCCEED);
65	}	68	}
66		69
67		70
68	/*	71	/*
69	* Get the whole file as a programming convenience in order to avoid	72	* Get the whole file as a programming convenience in order to avoid
70	* malloc+lseek+read+free of many pieces. If successful, then mmap	73	* malloc+lseek+read+free of many pieces. If successful, then mmap
71	* avoids copying unused pieces; else just read the whole file.	74	* avoids copying unused pieces; else just read the whole file.
72	* Open for both read and write.	75	* Open for both read and write.
73	*/	76	*/
74	static void mmap_file(char const fname)	77	static void mmap_file(char const fname)
75	{	78	{
76	void *addr;	79	void *addr;
77		80
78	fd_map = open(fname, O_RDWR);	81	fd_map = open(fname, O_RDWR);
79	if (fd_map < 0 \|\| fstat(fd_map, &sb) < 0) {	82	if (fd_map < 0 \|\| fstat(fd_map, &sb) < 0) {
80	perror(fname);	83	perror(fname);
81	fail_file();	84	fail_file();
82	}	85	}
83	if (!S_ISREG(sb.st_mode)) {	86	if (!S_ISREG(sb.st_mode)) {
84	fprintf(stderr, "not a regular file: %s\n", fname);	87	fprintf(stderr, "not a regular file: %s\n", fname);
85	fail_file();	88	fail_file();
86	}	89	}
87	addr = mmap(0, sb.st_size, PROT_READ\|PROT_WRITE, MAP_SHARED,	90	addr = mmap(0, sb.st_size, PROT_READ\|PROT_WRITE, MAP_SHARED,
88	fd_map, 0);	91	fd_map, 0);
89	if (addr == MAP_FAILED) {	92	if (addr == MAP_FAILED) {
90	mmap_failed = 1;	93	mmap_failed = 1;
91	fprintf(stderr, "Could not mmap file: %s\n", fname);	94	fprintf(stderr, "Could not mmap file: %s\n", fname);
92	fail_file();	95	fail_file();
93	}	96	}
94	return addr;	97	return addr;
95	}	98	}
96		99
97	/* w8rev, w8nat, ...: Handle endianness. */	100	static uint64_t r8be(const uint64_t *x)
98
99	static uint64_t w8rev(uint64_t const x)
100	{	101	{
101	return ((0xff & (x >> (0 * 8))) << (7 * 8))	102	return get_unaligned_be64(x);
102	\| ((0xff & (x >> (1 * 8))) << (6 * 8))
103	\| ((0xff & (x >> (2 * 8))) << (5 * 8))
104	\| ((0xff & (x >> (3 * 8))) << (4 * 8))
105	\| ((0xff & (x >> (4 * 8))) << (3 * 8))
106	\| ((0xff & (x >> (5 * 8))) << (2 * 8))
107	\| ((0xff & (x >> (6 * 8))) << (1 * 8))
108	\| ((0xff & (x >> (7 * 8))) << (0 * 8));
109	}	103	}
110		104	static uint32_t rbe(const uint32_t *x)
111	static uint32_t w4rev(uint32_t const x)
112	{	105	{
113	return ((0xff & (x >> (0 * 8))) << (3 * 8))	106	return get_unaligned_be32(x);
114	\| ((0xff & (x >> (1 * 8))) << (2 * 8))
115	\| ((0xff & (x >> (2 * 8))) << (1 * 8))
116	\| ((0xff & (x >> (3 * 8))) << (0 * 8));
117	}	107	}
118		108	static uint16_t r2be(const uint16_t *x)
119	static uint32_t w2rev(uint16_t const x)
120	{	109	{
121	return ((0xff & (x >> (0 * 8))) << (1 * 8))	110	return get_unaligned_be16(x);
122	\| ((0xff & (x >> (1 * 8))) << (0 * 8));
123	}	111	}
124		112	static uint64_t r8le(const uint64_t *x)
125	static uint64_t w8nat(uint64_t const x)
126	{	113	{
127	return x;	114	return get_unaligned_le64(x);
128	}	115	}
129		116	static uint32_t rle(const uint32_t *x)
130	static uint32_t w4nat(uint32_t const x)
131	{	117	{
132	return x;	118	return get_unaligned_le32(x);
133	}	119	}
		120	static uint16_t r2le(const uint16_t *x)
		121	{
		122	return get_unaligned_le16(x);
		123	}
134		124
135	static uint32_t w2nat(uint16_t const x)	125	static void w8be(uint64_t val, uint64_t *x)
136	{	126	{
137	return x;	127	put_unaligned_be64(val, x);
138	}	128	}
		129	static void wbe(uint32_t val, uint32_t *x)
		130	{
		131	put_unaligned_be32(val, x);
		132	}
		133	static void w2be(uint16_t val, uint16_t *x)
		134	{
		135	put_unaligned_be16(val, x);
		136	}
		137	static void w8le(uint64_t val, uint64_t *x)
		138	{
		139	put_unaligned_le64(val, x);
		140	}
		141	static void wle(uint32_t val, uint32_t *x)
		142	{
		143	put_unaligned_le32(val, x);
		144	}
		145	static void w2le(uint16_t val, uint16_t *x)
		146	{
		147	put_unaligned_le16(val, x);
		148	}
139		149
140	static uint64_t (*w8)(uint64_t);	150	static uint64_t (r8)(const uint64_t );
141	static uint32_t (*w)(uint32_t);	151	static uint32_t (r)(const uint32_t );
142	static uint32_t (*w2)(uint16_t);	152	static uint16_t (r2)(const uint16_t );
		153	static void (w8)(uint64_t, uint64_t );
		154	static void (w)(uint32_t, uint32_t );
		155	static void (w2)(uint16_t, uint16_t );
143		156
		157	typedef void (table_sort_t)(char , int);
144		158
145	/* 32 bit and 64 bit are very similar */	159	/* 32 bit and 64 bit are very similar */
146	#include "sortextable.h"	160	#include "sortextable.h"
147	#define SORTEXTABLE_64	161	#define SORTEXTABLE_64
148	#include "sortextable.h"	162	#include "sortextable.h"
149		163
		164	static int compare_x86_table(const void a, const void b)
		165	{
		166	int32_t av = (int32_t)r(a);
		167	int32_t bv = (int32_t)r(b);
150		168
		169	if (av < bv)
		170	return -1;
		171	if (av > bv)
		172	return 1;
		173	return 0;
		174	}
		175
		176	static void sort_x86_table(char *extab_image, int image_size)
		177	{
		178	int i;
		179
		180	/*
		181	* Do the same thing the runtime sort does, first normalize to
		182	* being relative to the start of the section.
		183	*/
		184	i = 0;
		185	while (i < image_size) {
		186	uint32_t loc = (uint32_t )(extab_image + i);
		187	w(r(loc) + i, loc);
		188	i += 4;
		189	}
		190
		191	qsort(extab_image, image_size / 8, 8, compare_x86_table);
		192
		193	/* Now denormalize. */
		194	i = 0;
		195	while (i < image_size) {
		196	uint32_t loc = (uint32_t )(extab_image + i);
		197	w(r(loc) - i, loc);
		198	i += 4;
		199	}
		200	}
		201
151	static void	202	static void
152	do_file(char const *const fname)	203	do_file(char const *const fname)
153	{	204	{
154	Elf32_Ehdr *const ehdr = mmap_file(fname);	205	table_sort_t custom_sort;
		206	Elf32_Ehdr *ehdr = mmap_file(fname);
155		207
156	ehdr_curr = ehdr;	208	ehdr_curr = ehdr;
157	w = w4nat;
158	w2 = w2nat;
159	w8 = w8nat;
160	switch (ehdr->e_ident[EI_DATA]) {	209	switch (ehdr->e_ident[EI_DATA]) {
161	static unsigned int const endian = 1;
162	default:	210	default:
163	fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",	211	fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
164	ehdr->e_ident[EI_DATA], fname);	212	ehdr->e_ident[EI_DATA], fname);
165	fail_file();	213	fail_file();
166	break;	214	break;
167	case ELFDATA2LSB:	215	case ELFDATA2LSB:
168	if ((unsigned char const )&endian != 1) {	216	r = rle;
169	/* main() is big endian, file.o is little endian. */	217	r2 = r2le;
170	w = w4rev;	218	r8 = r8le;
171	w2 = w2rev;	219	w = wle;
172	w8 = w8rev;	220	w2 = w2le;
173	}	221	w8 = w8le;
174	break;	222	break;
175	case ELFDATA2MSB:	223	case ELFDATA2MSB:
176	if ((unsigned char const )&endian != 0) {	224	r = rbe;
177	/* main() is little endian, file.o is big endian. */	225	r2 = r2be;
178	w = w4rev;	226	r8 = r8be;
179	w2 = w2rev;	227	w = wbe;
180	w8 = w8rev;	228	w2 = w2be;
181	}	229	w8 = w8be;
182	break;	230	break;
183	} /* end switch */	231	} /* end switch */
184	if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0	232	if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0
185	\|\| w2(ehdr->e_type) != ET_EXEC	233	\|\| r2(&ehdr->e_type) != ET_EXEC
186	\|\| ehdr->e_ident[EI_VERSION] != EV_CURRENT) {	234	\|\| ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
187	fprintf(stderr, "unrecognized ET_EXEC file %s\n", fname);	235	fprintf(stderr, "unrecognized ET_EXEC file %s\n", fname);
188	fail_file();	236	fail_file();
189	}	237	}
190		238
191	switch (w2(ehdr->e_machine)) {	239	custom_sort = NULL;
		240	switch (r2(&ehdr->e_machine)) {
192	default:	241	default:
193	fprintf(stderr, "unrecognized e_machine %d %s\n",	242	fprintf(stderr, "unrecognized e_machine %d %s\n",
194	w2(ehdr->e_machine), fname);	243	r2(&ehdr->e_machine), fname);
195	fail_file();	244	fail_file();
196	break;	245	break;
197	case EM_386:	246	case EM_386:
198	case EM_MIPS:
199	case EM_X86_64:	247	case EM_X86_64:
		248	custom_sort = sort_x86_table;
200	break;	249	break;
		250	case EM_MIPS:
		251	break;
201	} /* end switch */	252	} /* end switch */
202		253
203	switch (ehdr->e_ident[EI_CLASS]) {	254	switch (ehdr->e_ident[EI_CLASS]) {
204	default:	255	default:
205	fprintf(stderr, "unrecognized ELF class %d %s\n",	256	fprintf(stderr, "unrecognized ELF class %d %s\n",
206	ehdr->e_ident[EI_CLASS], fname);	257	ehdr->e_ident[EI_CLASS], fname);
207	fail_file();	258	fail_file();
208	break;	259	break;
209	case ELFCLASS32:	260	case ELFCLASS32:
210	if (w2(ehdr->e_ehsize) != sizeof(Elf32_Ehdr)	261	if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr)
211	\|\| w2(ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {	262	\|\| r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
212	fprintf(stderr,	263	fprintf(stderr,
213	"unrecognized ET_EXEC file: %s\n", fname);	264	"unrecognized ET_EXEC file: %s\n", fname);
214	fail_file();	265	fail_file();
215	}	266	}
216	do32(ehdr, fname);	267	do32(ehdr, fname, custom_sort);
217	break;	268	break;
218	case ELFCLASS64: {	269	case ELFCLASS64: {
219	Elf64_Ehdr const ghdr = (Elf64_Ehdr )ehdr;	270	Elf64_Ehdr const ghdr = (Elf64_Ehdr )ehdr;
220	if (w2(ghdr->e_ehsize) != sizeof(Elf64_Ehdr)	271	if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr)
221	\|\| w2(ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {	272	\|\| r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
222	fprintf(stderr,	273	fprintf(stderr,
223	"unrecognized ET_EXEC file: %s\n", fname);	274	"unrecognized ET_EXEC file: %s\n", fname);
224	fail_file();	275	fail_file();
225	}	276	}
226	do64(ghdr, fname);	277	do64(ghdr, fname, custom_sort);
227	break;	278	break;
228	}	279	}
229	} /* end switch */	280	} /* end switch */
230		281
231	cleanup();	282	cleanup();
232	}	283	}
233		284
234	int	285	int
235	main(int argc, char *argv[])	286	main(int argc, char *argv[])
236	{	287	{
237	int n_error = 0; /* gcc-4.3.0 false positive complaint */	288	int n_error = 0; /* gcc-4.3.0 false positive complaint */
238	int i;	289	int i;
239		290
240	if (argc < 2) {	291	if (argc < 2) {
241	fprintf(stderr, "usage: sortextable vmlinux...\n");	292	fprintf(stderr, "usage: sortextable vmlinux...\n");
242	return 0;	293	return 0;
243	}	294	}
244		295
245	/* Process each file in turn, allowing deep failure. */	296	/* Process each file in turn, allowing deep failure. */
246	for (i = 1; i < argc; i++) {	297	for (i = 1; i < argc; i++) {
247	char *file = argv[i];	298	char *file = argv[i];
248	int const sjval = setjmp(jmpenv);	299	int const sjval = setjmp(jmpenv);
249		300
250	switch (sjval) {	301	switch (sjval) {

scripts/sortextable.h

Diff comments View file @ d59a168

 /*
  * sortextable.h
  *
- * Copyright 2011 Cavium, Inc.
+ * Copyright 2011 - 2012 Cavium, Inc.
  *
  * Some of this code was taken out of recordmcount.h written by:
  *
  * Copyright 2009 John F. Reiser <jreiser@BitWagon.com>.  All rights reserved.
  * Copyright 2010 Steven Rostedt <srostedt@redhat.com>, Red Hat Inc.
  *
  *
  * Licensed under the GNU General Public License, version 2 (GPLv2).
  */
 #undef extable_ent_size
 #undef compare_extable
 #undef do_func
 #undef Elf_Addr
 #undef Elf_Ehdr
 #undef Elf_Shdr
 #undef Elf_Rel
 #undef Elf_Rela
 #undef Elf_Sym
 #undef ELF_R_SYM
 #undef Elf_r_sym
 #undef ELF_R_INFO
 #undef Elf_r_info
 #undef ELF_ST_BIND
 #undef ELF_ST_TYPE
 #undef fn_ELF_R_SYM
 #undef fn_ELF_R_INFO
 #undef uint_t
+#undef _r
 #undef _w
 #ifdef SORTEXTABLE_64
 # define extable_ent_size	16
 # define compare_extable	compare_extable_64
 # define do_func		do64
 # define Elf_Addr		Elf64_Addr
 # define Elf_Ehdr		Elf64_Ehdr
 # define Elf_Shdr		Elf64_Shdr
 # define Elf_Rel		Elf64_Rel
 # define Elf_Rela		Elf64_Rela
 # define Elf_Sym		Elf64_Sym
 # define ELF_R_SYM		ELF64_R_SYM
 # define Elf_r_sym		Elf64_r_sym
 # define ELF_R_INFO		ELF64_R_INFO
 # define Elf_r_info		Elf64_r_info
 # define ELF_ST_BIND		ELF64_ST_BIND
 # define ELF_ST_TYPE		ELF64_ST_TYPE
 # define fn_ELF_R_SYM		fn_ELF64_R_SYM
 # define fn_ELF_R_INFO		fn_ELF64_R_INFO
 # define uint_t			uint64_t
+# define _r			r8
 # define _w			w8
 #else
 # define extable_ent_size	8
 # define compare_extable	compare_extable_32
 # define do_func		do32
 # define Elf_Addr		Elf32_Addr
 # define Elf_Ehdr		Elf32_Ehdr
 # define Elf_Shdr		Elf32_Shdr
 # define Elf_Rel		Elf32_Rel
 # define Elf_Rela		Elf32_Rela
 # define Elf_Sym		Elf32_Sym
 # define ELF_R_SYM		ELF32_R_SYM
 # define Elf_r_sym		Elf32_r_sym
 # define ELF_R_INFO		ELF32_R_INFO
 # define Elf_r_info		Elf32_r_info
 # define ELF_ST_BIND		ELF32_ST_BIND
 # define ELF_ST_TYPE		ELF32_ST_TYPE
 # define fn_ELF_R_SYM		fn_ELF32_R_SYM
 # define fn_ELF_R_INFO		fn_ELF32_R_INFO
 # define uint_t			uint32_t
+# define _r			r
 # define _w			w
 #endif
 static int compare_extable(const void *a, const void *b)
 {
-	const uint_t *aa = a;
+	Elf_Addr av = _r(a);
-	const uint_t *bb = b;
+	Elf_Addr bv = _r(b);
-	if (_w(*aa) < _w(*bb))
+	if (av < bv)
 		return -1;
-	if (_w(*aa) > _w(*bb))
+	if (av > bv)
 		return 1;
 	return 0;
 }
 static void
-do_func(Elf_Ehdr *const ehdr, char const *const fname)
+do_func(Elf_Ehdr *ehdr, char const *const fname, table_sort_t custom_sort)
 {
 	Elf_Shdr *shdr;
 	Elf_Shdr *shstrtab_sec;
 	Elf_Shdr *strtab_sec = NULL;
 	Elf_Shdr *symtab_sec = NULL;
 	Elf_Shdr *extab_sec = NULL;
 	Elf_Sym *sym;
 	Elf_Sym *sort_needed_sym;
 	Elf_Shdr *sort_needed_sec;
+	Elf_Rel *relocs = NULL;
+	int relocs_size;
 	uint32_t *sort_done_location;
 	const char *secstrtab;
 	const char *strtab;
+	char *extab_image;
+	int extab_index = 0;
 	int i;
 	int idx;
-	shdr = (Elf_Shdr *)((void *)ehdr + _w(ehdr->e_shoff));
+	shdr = (Elf_Shdr *)((char *)ehdr + _r(&ehdr->e_shoff));
-	shstrtab_sec = shdr + w2(ehdr->e_shstrndx);
+	shstrtab_sec = shdr + r2(&ehdr->e_shstrndx);
-	secstrtab = (const char *)ehdr + _w(shstrtab_sec->sh_offset);
+	secstrtab = (const char *)ehdr + _r(&shstrtab_sec->sh_offset);
-	for (i = 0; i < w2(ehdr->e_shnum); i++) {
+	for (i = 0; i < r2(&ehdr->e_shnum); i++) {
-		idx = w(shdr[i].sh_name);
+		idx = r(&shdr[i].sh_name);
-		if (strcmp(secstrtab + idx, "__ex_table") == 0)
+		if (strcmp(secstrtab + idx, "__ex_table") == 0) {
 			extab_sec = shdr + i;
+			extab_index = i;
+		}
+		if ((r(&shdr[i].sh_type) == SHT_REL ||
+		     r(&shdr[i].sh_type) == SHT_RELA) &&
+		    r(&shdr[i].sh_info) == extab_index) {
+			relocs = (void *)ehdr + _r(&shdr[i].sh_offset);
+			relocs_size = _r(&shdr[i].sh_size);
+		}
 		if (strcmp(secstrtab + idx, ".symtab") == 0)
 			symtab_sec = shdr + i;
 		if (strcmp(secstrtab + idx, ".strtab") == 0)
 			strtab_sec = shdr + i;
 	}
 	if (strtab_sec == NULL) {
 		fprintf(stderr,	"no .strtab in  file: %s\n", fname);
 		fail_file();
 	}
 	if (symtab_sec == NULL) {
 		fprintf(stderr,	"no .symtab in  file: %s\n", fname);
 		fail_file();
 	}
 	if (extab_sec == NULL) {
 		fprintf(stderr,	"no __ex_table in  file: %s\n", fname);
 		fail_file();
 	}
-	strtab = (const char *)ehdr + _w(strtab_sec->sh_offset);
+	strtab = (const char *)ehdr + _r(&strtab_sec->sh_offset);
-	/* Sort the table in place */
+	extab_image = (void *)ehdr + _r(&extab_sec->sh_offset);
-	qsort((void *)ehdr + _w(extab_sec->sh_offset),
-	      (_w(extab_sec->sh_size) / extable_ent_size),
-	      extable_ent_size, compare_extable);
+	if (custom_sort) {
+		custom_sort(extab_image, _r(&extab_sec->sh_size));
+	} else {
+		int num_entries = _r(&extab_sec->sh_size) / extable_ent_size;
+		qsort(extab_image, num_entries,
+		      extable_ent_size, compare_extable);
+	}
+	/* If there were relocations, we no longer need them. */
+	if (relocs)
+		memset(relocs, 0, relocs_size);
 	/* find main_extable_sort_needed */
 	sort_needed_sym = NULL;
-	for (i = 0; i < _w(symtab_sec->sh_size) / sizeof(Elf_Sym); i++) {
+	for (i = 0; i < _r(&symtab_sec->sh_size) / sizeof(Elf_Sym); i++) {
-		sym = (void *)ehdr + _w(symtab_sec->sh_offset);
+		sym = (void *)ehdr + _r(&symtab_sec->sh_offset);
 		sym += i;
 		if (ELF_ST_TYPE(sym->st_info) != STT_OBJECT)
 			continue;
-		idx = w(sym->st_name);
+		idx = r(&sym->st_name);
 		if (strcmp(strtab + idx, "main_extable_sort_needed") == 0) {
 			sort_needed_sym = sym;
 			break;
 		}
 	}
 	if (sort_needed_sym == NULL) {
 		fprintf(stderr,
 			"no main_extable_sort_needed symbol in  file: %s\n",
 			fname);
 		fail_file();
 	}
-	sort_needed_sec = &shdr[w2(sort_needed_sym->st_shndx)];
+	sort_needed_sec = &shdr[r2(&sort_needed_sym->st_shndx)];
 	sort_done_location = (void *)ehdr +
-		_w(sort_needed_sec->sh_offset) +
+		_r(&sort_needed_sec->sh_offset) +
-		_w(sort_needed_sym->st_value) -
+		_r(&sort_needed_sym->st_value) -
-		_w(sort_needed_sec->sh_addr);
+		_r(&sort_needed_sec->sh_addr);
+#if 1
 	printf("sort done marker at %lx\n",
-		(unsigned long) (_w(sort_needed_sec->sh_offset) +
+	       (unsigned long)((char *)sort_done_location - (char *)ehdr));
-				 _w(sort_needed_sym->st_value) -
+#endif
-				 _w(sort_needed_sec->sh_addr)));