Merge tag 'xfs-5.13-merge-5' of git://git.kernel.org/pub/scm/fs/xfs/xfs-linux
[platform/kernel/linux-starfive.git] / scripts / kallsyms.c
1 /* Generate assembler source containing symbol information
2  *
3  * Copyright 2002       by Kai Germaschewski
4  *
5  * This software may be used and distributed according to the terms
6  * of the GNU General Public License, incorporated herein by reference.
7  *
8  * Usage: nm -n vmlinux | scripts/kallsyms [--all-symbols] > symbols.S
9  *
10  *      Table compression uses all the unused char codes on the symbols and
11  *  maps these to the most used substrings (tokens). For instance, it might
12  *  map char code 0xF7 to represent "write_" and then in every symbol where
13  *  "write_" appears it can be replaced by 0xF7, saving 5 bytes.
14  *      The used codes themselves are also placed in the table so that the
15  *  decompresion can work without "special cases".
16  *      Applied to kernel symbols, this usually produces a compression ratio
17  *  of about 50%.
18  *
19  */
20
21 #include <stdbool.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #include <limits.h>
27
28 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0]))
29
30 #define KSYM_NAME_LEN           128
31
32 struct sym_entry {
33         unsigned long long addr;
34         unsigned int len;
35         unsigned int start_pos;
36         unsigned int percpu_absolute;
37         unsigned char sym[];
38 };
39
40 struct addr_range {
41         const char *start_sym, *end_sym;
42         unsigned long long start, end;
43 };
44
45 static unsigned long long _text;
46 static unsigned long long relative_base;
47 static struct addr_range text_ranges[] = {
48         { "_stext",     "_etext"     },
49         { "_sinittext", "_einittext" },
50 };
51 #define text_range_text     (&text_ranges[0])
52 #define text_range_inittext (&text_ranges[1])
53
54 static struct addr_range percpu_range = {
55         "__per_cpu_start", "__per_cpu_end", -1ULL, 0
56 };
57
58 static struct sym_entry **table;
59 static unsigned int table_size, table_cnt;
60 static int all_symbols;
61 static int absolute_percpu;
62 static int base_relative;
63
64 static int token_profit[0x10000];
65
66 /* the table that holds the result of the compression */
67 static unsigned char best_table[256][2];
68 static unsigned char best_table_len[256];
69
70
71 static void usage(void)
72 {
73         fprintf(stderr, "Usage: kallsyms [--all-symbols] "
74                         "[--base-relative] < in.map > out.S\n");
75         exit(1);
76 }
77
78 static char *sym_name(const struct sym_entry *s)
79 {
80         return (char *)s->sym + 1;
81 }
82
83 static bool is_ignored_symbol(const char *name, char type)
84 {
85         /* Symbol names that exactly match to the following are ignored.*/
86         static const char * const ignored_symbols[] = {
87                 /*
88                  * Symbols which vary between passes. Passes 1 and 2 must have
89                  * identical symbol lists. The kallsyms_* symbols below are
90                  * only added after pass 1, they would be included in pass 2
91                  * when --all-symbols is specified so exclude them to get a
92                  * stable symbol list.
93                  */
94                 "kallsyms_addresses",
95                 "kallsyms_offsets",
96                 "kallsyms_relative_base",
97                 "kallsyms_num_syms",
98                 "kallsyms_names",
99                 "kallsyms_markers",
100                 "kallsyms_token_table",
101                 "kallsyms_token_index",
102                 /* Exclude linker generated symbols which vary between passes */
103                 "_SDA_BASE_",           /* ppc */
104                 "_SDA2_BASE_",          /* ppc */
105                 NULL
106         };
107
108         /* Symbol names that begin with the following are ignored.*/
109         static const char * const ignored_prefixes[] = {
110                 "$",                    /* local symbols for ARM, MIPS, etc. */
111                 ".LASANPC",             /* s390 kasan local symbols */
112                 "__crc_",               /* modversions */
113                 "__efistub_",           /* arm64 EFI stub namespace */
114                 "__kvm_nvhe_",          /* arm64 non-VHE KVM namespace */
115                 "__AArch64ADRPThunk_",  /* arm64 lld */
116                 "__ARMV5PILongThunk_",  /* arm lld */
117                 "__ARMV7PILongThunk_",
118                 "__ThumbV7PILongThunk_",
119                 "__LA25Thunk_",         /* mips lld */
120                 "__microLA25Thunk_",
121                 NULL
122         };
123
124         /* Symbol names that end with the following are ignored.*/
125         static const char * const ignored_suffixes[] = {
126                 "_from_arm",            /* arm */
127                 "_from_thumb",          /* arm */
128                 "_veneer",              /* arm */
129                 NULL
130         };
131
132         /* Symbol names that contain the following are ignored.*/
133         static const char * const ignored_matches[] = {
134                 ".long_branch.",        /* ppc stub */
135                 ".plt_branch.",         /* ppc stub */
136                 NULL
137         };
138
139         const char * const *p;
140
141         for (p = ignored_symbols; *p; p++)
142                 if (!strcmp(name, *p))
143                         return true;
144
145         for (p = ignored_prefixes; *p; p++)
146                 if (!strncmp(name, *p, strlen(*p)))
147                         return true;
148
149         for (p = ignored_suffixes; *p; p++) {
150                 int l = strlen(name) - strlen(*p);
151
152                 if (l >= 0 && !strcmp(name + l, *p))
153                         return true;
154         }
155
156         for (p = ignored_matches; *p; p++) {
157                 if (strstr(name, *p))
158                         return true;
159         }
160
161         if (type == 'U' || type == 'u')
162                 return true;
163         /* exclude debugging symbols */
164         if (type == 'N' || type == 'n')
165                 return true;
166
167         if (toupper(type) == 'A') {
168                 /* Keep these useful absolute symbols */
169                 if (strcmp(name, "__kernel_syscall_via_break") &&
170                     strcmp(name, "__kernel_syscall_via_epc") &&
171                     strcmp(name, "__kernel_sigtramp") &&
172                     strcmp(name, "__gp"))
173                         return true;
174         }
175
176         return false;
177 }
178
179 static void check_symbol_range(const char *sym, unsigned long long addr,
180                                struct addr_range *ranges, int entries)
181 {
182         size_t i;
183         struct addr_range *ar;
184
185         for (i = 0; i < entries; ++i) {
186                 ar = &ranges[i];
187
188                 if (strcmp(sym, ar->start_sym) == 0) {
189                         ar->start = addr;
190                         return;
191                 } else if (strcmp(sym, ar->end_sym) == 0) {
192                         ar->end = addr;
193                         return;
194                 }
195         }
196 }
197
198 static struct sym_entry *read_symbol(FILE *in)
199 {
200         char name[500], type;
201         unsigned long long addr;
202         unsigned int len;
203         struct sym_entry *sym;
204         int rc;
205
206         rc = fscanf(in, "%llx %c %499s\n", &addr, &type, name);
207         if (rc != 3) {
208                 if (rc != EOF && fgets(name, 500, in) == NULL)
209                         fprintf(stderr, "Read error or end of file.\n");
210                 return NULL;
211         }
212         if (strlen(name) >= KSYM_NAME_LEN) {
213                 fprintf(stderr, "Symbol %s too long for kallsyms (%zu >= %d).\n"
214                                 "Please increase KSYM_NAME_LEN both in kernel and kallsyms.c\n",
215                         name, strlen(name), KSYM_NAME_LEN);
216                 return NULL;
217         }
218
219         if (strcmp(name, "_text") == 0)
220                 _text = addr;
221
222         /* Ignore most absolute/undefined (?) symbols. */
223         if (is_ignored_symbol(name, type))
224                 return NULL;
225
226         check_symbol_range(name, addr, text_ranges, ARRAY_SIZE(text_ranges));
227         check_symbol_range(name, addr, &percpu_range, 1);
228
229         /* include the type field in the symbol name, so that it gets
230          * compressed together */
231
232         len = strlen(name) + 1;
233
234         sym = malloc(sizeof(*sym) + len + 1);
235         if (!sym) {
236                 fprintf(stderr, "kallsyms failure: "
237                         "unable to allocate required amount of memory\n");
238                 exit(EXIT_FAILURE);
239         }
240         sym->addr = addr;
241         sym->len = len;
242         sym->sym[0] = type;
243         strcpy(sym_name(sym), name);
244         sym->percpu_absolute = 0;
245
246         return sym;
247 }
248
249 static int symbol_in_range(const struct sym_entry *s,
250                            const struct addr_range *ranges, int entries)
251 {
252         size_t i;
253         const struct addr_range *ar;
254
255         for (i = 0; i < entries; ++i) {
256                 ar = &ranges[i];
257
258                 if (s->addr >= ar->start && s->addr <= ar->end)
259                         return 1;
260         }
261
262         return 0;
263 }
264
265 static int symbol_valid(const struct sym_entry *s)
266 {
267         const char *name = sym_name(s);
268
269         /* if --all-symbols is not specified, then symbols outside the text
270          * and inittext sections are discarded */
271         if (!all_symbols) {
272                 if (symbol_in_range(s, text_ranges,
273                                     ARRAY_SIZE(text_ranges)) == 0)
274                         return 0;
275                 /* Corner case.  Discard any symbols with the same value as
276                  * _etext _einittext; they can move between pass 1 and 2 when
277                  * the kallsyms data are added.  If these symbols move then
278                  * they may get dropped in pass 2, which breaks the kallsyms
279                  * rules.
280                  */
281                 if ((s->addr == text_range_text->end &&
282                      strcmp(name, text_range_text->end_sym)) ||
283                     (s->addr == text_range_inittext->end &&
284                      strcmp(name, text_range_inittext->end_sym)))
285                         return 0;
286         }
287
288         return 1;
289 }
290
291 /* remove all the invalid symbols from the table */
292 static void shrink_table(void)
293 {
294         unsigned int i, pos;
295
296         pos = 0;
297         for (i = 0; i < table_cnt; i++) {
298                 if (symbol_valid(table[i])) {
299                         if (pos != i)
300                                 table[pos] = table[i];
301                         pos++;
302                 } else {
303                         free(table[i]);
304                 }
305         }
306         table_cnt = pos;
307
308         /* When valid symbol is not registered, exit to error */
309         if (!table_cnt) {
310                 fprintf(stderr, "No valid symbol.\n");
311                 exit(1);
312         }
313 }
314
315 static void read_map(FILE *in)
316 {
317         struct sym_entry *sym;
318
319         while (!feof(in)) {
320                 sym = read_symbol(in);
321                 if (!sym)
322                         continue;
323
324                 sym->start_pos = table_cnt;
325
326                 if (table_cnt >= table_size) {
327                         table_size += 10000;
328                         table = realloc(table, sizeof(*table) * table_size);
329                         if (!table) {
330                                 fprintf(stderr, "out of memory\n");
331                                 exit (1);
332                         }
333                 }
334
335                 table[table_cnt++] = sym;
336         }
337 }
338
339 static void output_label(const char *label)
340 {
341         printf(".globl %s\n", label);
342         printf("\tALGN\n");
343         printf("%s:\n", label);
344 }
345
346 /* Provide proper symbols relocatability by their '_text' relativeness. */
347 static void output_address(unsigned long long addr)
348 {
349         if (_text <= addr)
350                 printf("\tPTR\t_text + %#llx\n", addr - _text);
351         else
352                 printf("\tPTR\t_text - %#llx\n", _text - addr);
353 }
354
355 /* uncompress a compressed symbol. When this function is called, the best table
356  * might still be compressed itself, so the function needs to be recursive */
357 static int expand_symbol(const unsigned char *data, int len, char *result)
358 {
359         int c, rlen, total=0;
360
361         while (len) {
362                 c = *data;
363                 /* if the table holds a single char that is the same as the one
364                  * we are looking for, then end the search */
365                 if (best_table[c][0]==c && best_table_len[c]==1) {
366                         *result++ = c;
367                         total++;
368                 } else {
369                         /* if not, recurse and expand */
370                         rlen = expand_symbol(best_table[c], best_table_len[c], result);
371                         total += rlen;
372                         result += rlen;
373                 }
374                 data++;
375                 len--;
376         }
377         *result=0;
378
379         return total;
380 }
381
382 static int symbol_absolute(const struct sym_entry *s)
383 {
384         return s->percpu_absolute;
385 }
386
387 static void write_src(void)
388 {
389         unsigned int i, k, off;
390         unsigned int best_idx[256];
391         unsigned int *markers;
392         char buf[KSYM_NAME_LEN];
393
394         printf("#include <asm/bitsperlong.h>\n");
395         printf("#if BITS_PER_LONG == 64\n");
396         printf("#define PTR .quad\n");
397         printf("#define ALGN .balign 8\n");
398         printf("#else\n");
399         printf("#define PTR .long\n");
400         printf("#define ALGN .balign 4\n");
401         printf("#endif\n");
402
403         printf("\t.section .rodata, \"a\"\n");
404
405         if (!base_relative)
406                 output_label("kallsyms_addresses");
407         else
408                 output_label("kallsyms_offsets");
409
410         for (i = 0; i < table_cnt; i++) {
411                 if (base_relative) {
412                         /*
413                          * Use the offset relative to the lowest value
414                          * encountered of all relative symbols, and emit
415                          * non-relocatable fixed offsets that will be fixed
416                          * up at runtime.
417                          */
418
419                         long long offset;
420                         int overflow;
421
422                         if (!absolute_percpu) {
423                                 offset = table[i]->addr - relative_base;
424                                 overflow = (offset < 0 || offset > UINT_MAX);
425                         } else if (symbol_absolute(table[i])) {
426                                 offset = table[i]->addr;
427                                 overflow = (offset < 0 || offset > INT_MAX);
428                         } else {
429                                 offset = relative_base - table[i]->addr - 1;
430                                 overflow = (offset < INT_MIN || offset >= 0);
431                         }
432                         if (overflow) {
433                                 fprintf(stderr, "kallsyms failure: "
434                                         "%s symbol value %#llx out of range in relative mode\n",
435                                         symbol_absolute(table[i]) ? "absolute" : "relative",
436                                         table[i]->addr);
437                                 exit(EXIT_FAILURE);
438                         }
439                         printf("\t.long\t%#x\n", (int)offset);
440                 } else if (!symbol_absolute(table[i])) {
441                         output_address(table[i]->addr);
442                 } else {
443                         printf("\tPTR\t%#llx\n", table[i]->addr);
444                 }
445         }
446         printf("\n");
447
448         if (base_relative) {
449                 output_label("kallsyms_relative_base");
450                 output_address(relative_base);
451                 printf("\n");
452         }
453
454         output_label("kallsyms_num_syms");
455         printf("\t.long\t%u\n", table_cnt);
456         printf("\n");
457
458         /* table of offset markers, that give the offset in the compressed stream
459          * every 256 symbols */
460         markers = malloc(sizeof(unsigned int) * ((table_cnt + 255) / 256));
461         if (!markers) {
462                 fprintf(stderr, "kallsyms failure: "
463                         "unable to allocate required memory\n");
464                 exit(EXIT_FAILURE);
465         }
466
467         output_label("kallsyms_names");
468         off = 0;
469         for (i = 0; i < table_cnt; i++) {
470                 if ((i & 0xFF) == 0)
471                         markers[i >> 8] = off;
472
473                 printf("\t.byte 0x%02x", table[i]->len);
474                 for (k = 0; k < table[i]->len; k++)
475                         printf(", 0x%02x", table[i]->sym[k]);
476                 printf("\n");
477
478                 off += table[i]->len + 1;
479         }
480         printf("\n");
481
482         output_label("kallsyms_markers");
483         for (i = 0; i < ((table_cnt + 255) >> 8); i++)
484                 printf("\t.long\t%u\n", markers[i]);
485         printf("\n");
486
487         free(markers);
488
489         output_label("kallsyms_token_table");
490         off = 0;
491         for (i = 0; i < 256; i++) {
492                 best_idx[i] = off;
493                 expand_symbol(best_table[i], best_table_len[i], buf);
494                 printf("\t.asciz\t\"%s\"\n", buf);
495                 off += strlen(buf) + 1;
496         }
497         printf("\n");
498
499         output_label("kallsyms_token_index");
500         for (i = 0; i < 256; i++)
501                 printf("\t.short\t%d\n", best_idx[i]);
502         printf("\n");
503 }
504
505
506 /* table lookup compression functions */
507
508 /* count all the possible tokens in a symbol */
509 static void learn_symbol(const unsigned char *symbol, int len)
510 {
511         int i;
512
513         for (i = 0; i < len - 1; i++)
514                 token_profit[ symbol[i] + (symbol[i + 1] << 8) ]++;
515 }
516
517 /* decrease the count for all the possible tokens in a symbol */
518 static void forget_symbol(const unsigned char *symbol, int len)
519 {
520         int i;
521
522         for (i = 0; i < len - 1; i++)
523                 token_profit[ symbol[i] + (symbol[i + 1] << 8) ]--;
524 }
525
526 /* do the initial token count */
527 static void build_initial_tok_table(void)
528 {
529         unsigned int i;
530
531         for (i = 0; i < table_cnt; i++)
532                 learn_symbol(table[i]->sym, table[i]->len);
533 }
534
535 static unsigned char *find_token(unsigned char *str, int len,
536                                  const unsigned char *token)
537 {
538         int i;
539
540         for (i = 0; i < len - 1; i++) {
541                 if (str[i] == token[0] && str[i+1] == token[1])
542                         return &str[i];
543         }
544         return NULL;
545 }
546
547 /* replace a given token in all the valid symbols. Use the sampled symbols
548  * to update the counts */
549 static void compress_symbols(const unsigned char *str, int idx)
550 {
551         unsigned int i, len, size;
552         unsigned char *p1, *p2;
553
554         for (i = 0; i < table_cnt; i++) {
555
556                 len = table[i]->len;
557                 p1 = table[i]->sym;
558
559                 /* find the token on the symbol */
560                 p2 = find_token(p1, len, str);
561                 if (!p2) continue;
562
563                 /* decrease the counts for this symbol's tokens */
564                 forget_symbol(table[i]->sym, len);
565
566                 size = len;
567
568                 do {
569                         *p2 = idx;
570                         p2++;
571                         size -= (p2 - p1);
572                         memmove(p2, p2 + 1, size);
573                         p1 = p2;
574                         len--;
575
576                         if (size < 2) break;
577
578                         /* find the token on the symbol */
579                         p2 = find_token(p1, size, str);
580
581                 } while (p2);
582
583                 table[i]->len = len;
584
585                 /* increase the counts for this symbol's new tokens */
586                 learn_symbol(table[i]->sym, len);
587         }
588 }
589
590 /* search the token with the maximum profit */
591 static int find_best_token(void)
592 {
593         int i, best, bestprofit;
594
595         bestprofit=-10000;
596         best = 0;
597
598         for (i = 0; i < 0x10000; i++) {
599                 if (token_profit[i] > bestprofit) {
600                         best = i;
601                         bestprofit = token_profit[i];
602                 }
603         }
604         return best;
605 }
606
607 /* this is the core of the algorithm: calculate the "best" table */
608 static void optimize_result(void)
609 {
610         int i, best;
611
612         /* using the '\0' symbol last allows compress_symbols to use standard
613          * fast string functions */
614         for (i = 255; i >= 0; i--) {
615
616                 /* if this table slot is empty (it is not used by an actual
617                  * original char code */
618                 if (!best_table_len[i]) {
619
620                         /* find the token with the best profit value */
621                         best = find_best_token();
622                         if (token_profit[best] == 0)
623                                 break;
624
625                         /* place it in the "best" table */
626                         best_table_len[i] = 2;
627                         best_table[i][0] = best & 0xFF;
628                         best_table[i][1] = (best >> 8) & 0xFF;
629
630                         /* replace this token in all the valid symbols */
631                         compress_symbols(best_table[i], i);
632                 }
633         }
634 }
635
636 /* start by placing the symbols that are actually used on the table */
637 static void insert_real_symbols_in_table(void)
638 {
639         unsigned int i, j, c;
640
641         for (i = 0; i < table_cnt; i++) {
642                 for (j = 0; j < table[i]->len; j++) {
643                         c = table[i]->sym[j];
644                         best_table[c][0]=c;
645                         best_table_len[c]=1;
646                 }
647         }
648 }
649
650 static void optimize_token_table(void)
651 {
652         build_initial_tok_table();
653
654         insert_real_symbols_in_table();
655
656         optimize_result();
657 }
658
659 /* guess for "linker script provide" symbol */
660 static int may_be_linker_script_provide_symbol(const struct sym_entry *se)
661 {
662         const char *symbol = sym_name(se);
663         int len = se->len - 1;
664
665         if (len < 8)
666                 return 0;
667
668         if (symbol[0] != '_' || symbol[1] != '_')
669                 return 0;
670
671         /* __start_XXXXX */
672         if (!memcmp(symbol + 2, "start_", 6))
673                 return 1;
674
675         /* __stop_XXXXX */
676         if (!memcmp(symbol + 2, "stop_", 5))
677                 return 1;
678
679         /* __end_XXXXX */
680         if (!memcmp(symbol + 2, "end_", 4))
681                 return 1;
682
683         /* __XXXXX_start */
684         if (!memcmp(symbol + len - 6, "_start", 6))
685                 return 1;
686
687         /* __XXXXX_end */
688         if (!memcmp(symbol + len - 4, "_end", 4))
689                 return 1;
690
691         return 0;
692 }
693
694 static int compare_symbols(const void *a, const void *b)
695 {
696         const struct sym_entry *sa = *(const struct sym_entry **)a;
697         const struct sym_entry *sb = *(const struct sym_entry **)b;
698         int wa, wb;
699
700         /* sort by address first */
701         if (sa->addr > sb->addr)
702                 return 1;
703         if (sa->addr < sb->addr)
704                 return -1;
705
706         /* sort by "weakness" type */
707         wa = (sa->sym[0] == 'w') || (sa->sym[0] == 'W');
708         wb = (sb->sym[0] == 'w') || (sb->sym[0] == 'W');
709         if (wa != wb)
710                 return wa - wb;
711
712         /* sort by "linker script provide" type */
713         wa = may_be_linker_script_provide_symbol(sa);
714         wb = may_be_linker_script_provide_symbol(sb);
715         if (wa != wb)
716                 return wa - wb;
717
718         /* sort by the number of prefix underscores */
719         wa = strspn(sym_name(sa), "_");
720         wb = strspn(sym_name(sb), "_");
721         if (wa != wb)
722                 return wa - wb;
723
724         /* sort by initial order, so that other symbols are left undisturbed */
725         return sa->start_pos - sb->start_pos;
726 }
727
728 static void sort_symbols(void)
729 {
730         qsort(table, table_cnt, sizeof(table[0]), compare_symbols);
731 }
732
733 static void make_percpus_absolute(void)
734 {
735         unsigned int i;
736
737         for (i = 0; i < table_cnt; i++)
738                 if (symbol_in_range(table[i], &percpu_range, 1)) {
739                         /*
740                          * Keep the 'A' override for percpu symbols to
741                          * ensure consistent behavior compared to older
742                          * versions of this tool.
743                          */
744                         table[i]->sym[0] = 'A';
745                         table[i]->percpu_absolute = 1;
746                 }
747 }
748
749 /* find the minimum non-absolute symbol address */
750 static void record_relative_base(void)
751 {
752         unsigned int i;
753
754         for (i = 0; i < table_cnt; i++)
755                 if (!symbol_absolute(table[i])) {
756                         /*
757                          * The table is sorted by address.
758                          * Take the first non-absolute symbol value.
759                          */
760                         relative_base = table[i]->addr;
761                         return;
762                 }
763 }
764
765 int main(int argc, char **argv)
766 {
767         if (argc >= 2) {
768                 int i;
769                 for (i = 1; i < argc; i++) {
770                         if(strcmp(argv[i], "--all-symbols") == 0)
771                                 all_symbols = 1;
772                         else if (strcmp(argv[i], "--absolute-percpu") == 0)
773                                 absolute_percpu = 1;
774                         else if (strcmp(argv[i], "--base-relative") == 0)
775                                 base_relative = 1;
776                         else
777                                 usage();
778                 }
779         } else if (argc != 1)
780                 usage();
781
782         read_map(stdin);
783         shrink_table();
784         if (absolute_percpu)
785                 make_percpus_absolute();
786         sort_symbols();
787         if (base_relative)
788                 record_relative_base();
789         optimize_token_table();
790         write_src();
791
792         return 0;
793 }