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