1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <sys/types.h>
24#include <sys/mman.h>
25#include <sys/stat.h>
26#include <getopt.h>
27#include <elf.h>
28#include <fcntl.h>
29#include <stdio.h>
30#include <stdlib.h>
31#include <string.h>
32#include <unistd.h>
33#include <errno.h>
34#include <pthread.h>
35
36#include <tools/be_byteshift.h>
37#include <tools/le_byteshift.h>
38
39#ifndef EM_ARCOMPACT
40#define EM_ARCOMPACT 93
41#endif
42
43#ifndef EM_XTENSA
44#define EM_XTENSA 94
45#endif
46
47#ifndef EM_AARCH64
48#define EM_AARCH64 183
49#endif
50
51#ifndef EM_MICROBLAZE
52#define EM_MICROBLAZE 189
53#endif
54
55#ifndef EM_ARCV2
56#define EM_ARCV2 195
57#endif
58
59#ifndef EM_RISCV
60#define EM_RISCV 243
61#endif
62
63static uint32_t (*r)(const uint32_t *);
64static uint16_t (*r2)(const uint16_t *);
65static uint64_t (*r8)(const uint64_t *);
66static void (*w)(uint32_t, uint32_t *);
67static void (*w2)(uint16_t, uint16_t *);
68static void (*w8)(uint64_t, uint64_t *);
69typedef void (*table_sort_t)(char *, int);
70
71
72
73
74
75
76
77static void *mmap_file(char const *fname, size_t *size)
78{
79 int fd;
80 struct stat sb;
81 void *addr = NULL;
82
83 fd = open(fname, O_RDWR);
84 if (fd < 0) {
85 perror(fname);
86 return NULL;
87 }
88 if (fstat(fd, &sb) < 0) {
89 perror(fname);
90 goto out;
91 }
92 if (!S_ISREG(sb.st_mode)) {
93 fprintf(stderr, "not a regular file: %s\n", fname);
94 goto out;
95 }
96
97 addr = mmap(0, sb.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
98 if (addr == MAP_FAILED) {
99 fprintf(stderr, "Could not mmap file: %s\n", fname);
100 goto out;
101 }
102
103 *size = sb.st_size;
104
105out:
106 close(fd);
107 return addr;
108}
109
110static uint32_t rbe(const uint32_t *x)
111{
112 return get_unaligned_be32(x);
113}
114
115static uint16_t r2be(const uint16_t *x)
116{
117 return get_unaligned_be16(x);
118}
119
120static uint64_t r8be(const uint64_t *x)
121{
122 return get_unaligned_be64(x);
123}
124
125static uint32_t rle(const uint32_t *x)
126{
127 return get_unaligned_le32(x);
128}
129
130static uint16_t r2le(const uint16_t *x)
131{
132 return get_unaligned_le16(x);
133}
134
135static uint64_t r8le(const uint64_t *x)
136{
137 return get_unaligned_le64(x);
138}
139
140static void wbe(uint32_t val, uint32_t *x)
141{
142 put_unaligned_be32(val, x);
143}
144
145static void w2be(uint16_t val, uint16_t *x)
146{
147 put_unaligned_be16(val, x);
148}
149
150static void w8be(uint64_t val, uint64_t *x)
151{
152 put_unaligned_be64(val, x);
153}
154
155static void wle(uint32_t val, uint32_t *x)
156{
157 put_unaligned_le32(val, x);
158}
159
160static void w2le(uint16_t val, uint16_t *x)
161{
162 put_unaligned_le16(val, x);
163}
164
165static void w8le(uint64_t val, uint64_t *x)
166{
167 put_unaligned_le64(val, x);
168}
169
170
171
172
173
174
175#define SPECIAL(i) ((i) - (SHN_HIRESERVE + 1))
176
177static inline int is_shndx_special(unsigned int i)
178{
179 return i != SHN_XINDEX && i >= SHN_LORESERVE && i <= SHN_HIRESERVE;
180}
181
182
183static inline unsigned int get_secindex(unsigned int shndx,
184 unsigned int sym_offs,
185 const Elf32_Word *symtab_shndx_start)
186{
187 if (is_shndx_special(shndx))
188 return SPECIAL(shndx);
189 if (shndx != SHN_XINDEX)
190 return shndx;
191 return r(&symtab_shndx_start[sym_offs]);
192}
193
194
195#include "sorttable.h"
196#define SORTTABLE_64
197#include "sorttable.h"
198
199static int compare_relative_table(const void *a, const void *b)
200{
201 int32_t av = (int32_t)r(a);
202 int32_t bv = (int32_t)r(b);
203
204 if (av < bv)
205 return -1;
206 if (av > bv)
207 return 1;
208 return 0;
209}
210
211static void sort_relative_table(char *extab_image, int image_size)
212{
213 int i = 0;
214
215
216
217
218
219 while (i < image_size) {
220 uint32_t *loc = (uint32_t *)(extab_image + i);
221 w(r(loc) + i, loc);
222 i += 4;
223 }
224
225 qsort(extab_image, image_size / 8, 8, compare_relative_table);
226
227
228 i = 0;
229 while (i < image_size) {
230 uint32_t *loc = (uint32_t *)(extab_image + i);
231 w(r(loc) - i, loc);
232 i += 4;
233 }
234}
235
236static void sort_relative_table_with_data(char *extab_image, int image_size)
237{
238 int i = 0;
239
240 while (i < image_size) {
241 uint32_t *loc = (uint32_t *)(extab_image + i);
242
243 w(r(loc) + i, loc);
244 w(r(loc + 1) + i + 4, loc + 1);
245
246
247 i += sizeof(uint32_t) * 3;
248 }
249
250 qsort(extab_image, image_size / 12, 12, compare_relative_table);
251
252 i = 0;
253 while (i < image_size) {
254 uint32_t *loc = (uint32_t *)(extab_image + i);
255
256 w(r(loc) - i, loc);
257 w(r(loc + 1) - (i + 4), loc + 1);
258
259
260 i += sizeof(uint32_t) * 3;
261 }
262}
263
264static void s390_sort_relative_table(char *extab_image, int image_size)
265{
266 int i;
267
268 for (i = 0; i < image_size; i += 16) {
269 char *loc = extab_image + i;
270 uint64_t handler;
271
272 w(r((uint32_t *)loc) + i, (uint32_t *)loc);
273 w(r((uint32_t *)(loc + 4)) + (i + 4), (uint32_t *)(loc + 4));
274
275
276
277
278
279
280
281
282 handler = r8((uint64_t *)(loc + 8));
283 if (handler)
284 handler += i + 8;
285 w8(handler, (uint64_t *)(loc + 8));
286 }
287
288 qsort(extab_image, image_size / 16, 16, compare_relative_table);
289
290 for (i = 0; i < image_size; i += 16) {
291 char *loc = extab_image + i;
292 uint64_t handler;
293
294 w(r((uint32_t *)loc) - i, (uint32_t *)loc);
295 w(r((uint32_t *)(loc + 4)) - (i + 4), (uint32_t *)(loc + 4));
296 handler = r8((uint64_t *)(loc + 8));
297 if (handler)
298 handler -= i + 8;
299 w8(handler, (uint64_t *)(loc + 8));
300 }
301}
302
303static int do_file(char const *const fname, void *addr)
304{
305 int rc = -1;
306 Elf32_Ehdr *ehdr = addr;
307 table_sort_t custom_sort = NULL;
308
309 switch (ehdr->e_ident[EI_DATA]) {
310 case ELFDATA2LSB:
311 r = rle;
312 r2 = r2le;
313 r8 = r8le;
314 w = wle;
315 w2 = w2le;
316 w8 = w8le;
317 break;
318 case ELFDATA2MSB:
319 r = rbe;
320 r2 = r2be;
321 r8 = r8be;
322 w = wbe;
323 w2 = w2be;
324 w8 = w8be;
325 break;
326 default:
327 fprintf(stderr, "unrecognized ELF data encoding %d: %s\n",
328 ehdr->e_ident[EI_DATA], fname);
329 return -1;
330 }
331
332 if (memcmp(ELFMAG, ehdr->e_ident, SELFMAG) != 0 ||
333 (r2(&ehdr->e_type) != ET_EXEC && r2(&ehdr->e_type) != ET_DYN) ||
334 ehdr->e_ident[EI_VERSION] != EV_CURRENT) {
335 fprintf(stderr, "unrecognized ET_EXEC/ET_DYN file %s\n", fname);
336 return -1;
337 }
338
339 switch (r2(&ehdr->e_machine)) {
340 case EM_386:
341 case EM_AARCH64:
342 case EM_RISCV:
343 case EM_X86_64:
344 custom_sort = sort_relative_table_with_data;
345 break;
346 case EM_S390:
347 custom_sort = s390_sort_relative_table;
348 break;
349 case EM_PARISC:
350 case EM_PPC:
351 case EM_PPC64:
352 custom_sort = sort_relative_table;
353 break;
354 case EM_ARCOMPACT:
355 case EM_ARCV2:
356 case EM_ARM:
357 case EM_MICROBLAZE:
358 case EM_MIPS:
359 case EM_XTENSA:
360 break;
361 default:
362 fprintf(stderr, "unrecognized e_machine %d %s\n",
363 r2(&ehdr->e_machine), fname);
364 return -1;
365 }
366
367 switch (ehdr->e_ident[EI_CLASS]) {
368 case ELFCLASS32:
369 if (r2(&ehdr->e_ehsize) != sizeof(Elf32_Ehdr) ||
370 r2(&ehdr->e_shentsize) != sizeof(Elf32_Shdr)) {
371 fprintf(stderr,
372 "unrecognized ET_EXEC/ET_DYN file: %s\n", fname);
373 break;
374 }
375 rc = do_sort_32(ehdr, fname, custom_sort);
376 break;
377 case ELFCLASS64:
378 {
379 Elf64_Ehdr *const ghdr = (Elf64_Ehdr *)ehdr;
380 if (r2(&ghdr->e_ehsize) != sizeof(Elf64_Ehdr) ||
381 r2(&ghdr->e_shentsize) != sizeof(Elf64_Shdr)) {
382 fprintf(stderr,
383 "unrecognized ET_EXEC/ET_DYN file: %s\n",
384 fname);
385 break;
386 }
387 rc = do_sort_64(ghdr, fname, custom_sort);
388 }
389 break;
390 default:
391 fprintf(stderr, "unrecognized ELF class %d %s\n",
392 ehdr->e_ident[EI_CLASS], fname);
393 break;
394 }
395
396 return rc;
397}
398
399int main(int argc, char *argv[])
400{
401 int i, n_error = 0;
402 size_t size = 0;
403 void *addr = NULL;
404
405 if (argc < 2) {
406 fprintf(stderr, "usage: sorttable vmlinux...\n");
407 return 0;
408 }
409
410
411 for (i = 1; i < argc; i++) {
412 addr = mmap_file(argv[i], &size);
413 if (!addr) {
414 ++n_error;
415 continue;
416 }
417
418 if (do_file(argv[i], addr))
419 ++n_error;
420
421 munmap(addr, size);
422 }
423
424 return !!n_error;
425}
426