~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/kallsyms.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp