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: kallsyms [--all-symbols] [--absolute-percpu] 9 * [--base-relative] in.map > out.S 10 * 11 * Table compression uses all the unused char codes on the symbols and 12 * maps these to the most used substrings (tokens). For instance, it might 13 * map char code 0xF7 to represent "write_" and then in every symbol where 14 * "write_" appears it can be replaced by 0xF7, saving 5 bytes. 15 * The used codes themselves are also placed in the table so that the 16 * decompresion can work without "special cases". 17 * Applied to kernel symbols, this usually produces a compression ratio 18 * of about 50%. 19 * 20 */ 21 22 #include <getopt.h> 23 #include <stdbool.h> 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <string.h> 27 #include <ctype.h> 28 #include <limits.h> 29 30 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof(arr[0])) 31 32 #define _stringify_1(x) #x 33 #define _stringify(x) _stringify_1(x) 34 35 #define KSYM_NAME_LEN 512 36 37 /* 38 * A substantially bigger size than the current maximum. 39 * 40 * It cannot be defined as an expression because it gets stringified 41 * for the fscanf() format string. Therefore, a _Static_assert() is 42 * used instead to maintain the relationship with KSYM_NAME_LEN. 43 */ 44 #define KSYM_NAME_LEN_BUFFER 2048 45 _Static_assert( 46 KSYM_NAME_LEN_BUFFER == KSYM_NAME_LEN * 4, 47 "Please keep KSYM_NAME_LEN_BUFFER in sync with KSYM_NAME_LEN" 48 ); 49 50 struct sym_entry { 51 unsigned long long addr; 52 unsigned int len; 53 unsigned int seq; 54 unsigned int start_pos; 55 unsigned int percpu_absolute; 56 unsigned char sym[]; 57 }; 58 59 struct addr_range { 60 const char *start_sym, *end_sym; 61 unsigned long long start, end; 62 }; 63 64 static unsigned long long _text; 65 static unsigned long long relative_base; 66 static struct addr_range text_ranges[] = { 67 { "_stext", "_etext" }, 68 { "_sinittext", "_einittext" }, 69 }; 70 #define text_range_text (&text_ranges[0]) 71 #define text_range_inittext (&text_ranges[1]) 72 73 static struct addr_range percpu_range = { 74 "__per_cpu_start", "__per_cpu_end", -1ULL, 0 75 }; 76 77 static struct sym_entry **table; 78 static unsigned int table_size, table_cnt; 79 static int all_symbols; 80 static int absolute_percpu; 81 static int base_relative; 82 static int lto_clang; 83 84 static int token_profit[0x10000]; 85 86 /* the table that holds the result of the compression */ 87 static unsigned char best_table[256][2]; 88 static unsigned char best_table_len[256]; 89 90 91 static void usage(void) 92 { 93 fprintf(stderr, "Usage: kallsyms [--all-symbols] [--absolute-percpu] " 94 "[--base-relative] [--lto-clang] in.map > out.S\n"); 95 exit(1); 96 } 97 98 static char *sym_name(const struct sym_entry *s) 99 { 100 return (char *)s->sym + 1; 101 } 102 103 static bool is_ignored_symbol(const char *name, char type) 104 { 105 /* Symbol names that exactly match to the following are ignored.*/ 106 static const char * const ignored_symbols[] = { 107 /* 108 * Symbols which vary between passes. Passes 1 and 2 must have 109 * identical symbol lists. The kallsyms_* symbols below are 110 * only added after pass 1, they would be included in pass 2 111 * when --all-symbols is specified so exclude them to get a 112 * stable symbol list. 113 */ 114 "kallsyms_addresses", 115 "kallsyms_offsets", 116 "kallsyms_relative_base", 117 "kallsyms_num_syms", 118 "kallsyms_names", 119 "kallsyms_markers", 120 "kallsyms_token_table", 121 "kallsyms_token_index", 122 "kallsyms_seqs_of_names", 123 /* Exclude linker generated symbols which vary between passes */ 124 "_SDA_BASE_", /* ppc */ 125 "_SDA2_BASE_", /* ppc */ 126 NULL 127 }; 128 129 /* Symbol names that begin with the following are ignored.*/ 130 static const char * const ignored_prefixes[] = { 131 "__efistub_", /* arm64 EFI stub namespace */ 132 "__kvm_nvhe_$", /* arm64 local symbols in non-VHE KVM namespace */ 133 "__kvm_nvhe_.L", /* arm64 local symbols in non-VHE KVM namespace */ 134 "__AArch64ADRPThunk_", /* arm64 lld */ 135 "__ARMV5PILongThunk_", /* arm lld */ 136 "__ARMV7PILongThunk_", 137 "__ThumbV7PILongThunk_", 138 "__LA25Thunk_", /* mips lld */ 139 "__microLA25Thunk_", 140 "__kcfi_typeid_", /* CFI type identifiers */ 141 NULL 142 }; 143 144 /* Symbol names that end with the following are ignored.*/ 145 static const char * const ignored_suffixes[] = { 146 "_from_arm", /* arm */ 147 "_from_thumb", /* arm */ 148 "_veneer", /* arm */ 149 NULL 150 }; 151 152 /* Symbol names that contain the following are ignored.*/ 153 static const char * const ignored_matches[] = { 154 ".long_branch.", /* ppc stub */ 155 ".plt_branch.", /* ppc stub */ 156 NULL 157 }; 158 159 const char * const *p; 160 161 for (p = ignored_symbols; *p; p++) 162 if (!strcmp(name, *p)) 163 return true; 164 165 for (p = ignored_prefixes; *p; p++) 166 if (!strncmp(name, *p, strlen(*p))) 167 return true; 168 169 for (p = ignored_suffixes; *p; p++) { 170 int l = strlen(name) - strlen(*p); 171 172 if (l >= 0 && !strcmp(name + l, *p)) 173 return true; 174 } 175 176 for (p = ignored_matches; *p; p++) { 177 if (strstr(name, *p)) 178 return true; 179 } 180 181 if (type == 'u' || type == 'n') 182 return true; 183 184 if (toupper(type) == 'A') { 185 /* Keep these useful absolute symbols */ 186 if (strcmp(name, "__kernel_syscall_via_break") && 187 strcmp(name, "__kernel_syscall_via_epc") && 188 strcmp(name, "__kernel_sigtramp") && 189 strcmp(name, "__gp")) 190 return true; 191 } 192 193 return false; 194 } 195 196 static void check_symbol_range(const char *sym, unsigned long long addr, 197 struct addr_range *ranges, int entries) 198 { 199 size_t i; 200 struct addr_range *ar; 201 202 for (i = 0; i < entries; ++i) { 203 ar = &ranges[i]; 204 205 if (strcmp(sym, ar->start_sym) == 0) { 206 ar->start = addr; 207 return; 208 } else if (strcmp(sym, ar->end_sym) == 0) { 209 ar->end = addr; 210 return; 211 } 212 } 213 } 214 215 static struct sym_entry *read_symbol(FILE *in) 216 { 217 char name[KSYM_NAME_LEN_BUFFER+1], type; 218 unsigned long long addr; 219 unsigned int len; 220 struct sym_entry *sym; 221 int rc; 222 223 rc = fscanf(in, "%llx %c %" _stringify(KSYM_NAME_LEN_BUFFER) "s\n", &addr, &type, name); 224 if (rc != 3) { 225 if (rc != EOF && fgets(name, ARRAY_SIZE(name), in) == NULL) 226 fprintf(stderr, "Read error or end of file.\n"); 227 return NULL; 228 } 229 if (strlen(name) >= KSYM_NAME_LEN) { 230 fprintf(stderr, "Symbol %s too long for kallsyms (%zu >= %d).\n" 231 "Please increase KSYM_NAME_LEN both in kernel and kallsyms.c\n", 232 name, strlen(name), KSYM_NAME_LEN); 233 return NULL; 234 } 235 236 if (strcmp(name, "_text") == 0) 237 _text = addr; 238 239 /* Ignore most absolute/undefined (?) symbols. */ 240 if (is_ignored_symbol(name, type)) 241 return NULL; 242 243 check_symbol_range(name, addr, text_ranges, ARRAY_SIZE(text_ranges)); 244 check_symbol_range(name, addr, &percpu_range, 1); 245 246 /* include the type field in the symbol name, so that it gets 247 * compressed together */ 248 249 len = strlen(name) + 1; 250 251 sym = malloc(sizeof(*sym) + len + 1); 252 if (!sym) { 253 fprintf(stderr, "kallsyms failure: " 254 "unable to allocate required amount of memory\n"); 255 exit(EXIT_FAILURE); 256 } 257 sym->addr = addr; 258 sym->len = len; 259 sym->sym[0] = type; 260 strcpy(sym_name(sym), name); 261 sym->percpu_absolute = 0; 262 263 return sym; 264 } 265 266 static int symbol_in_range(const struct sym_entry *s, 267 const struct addr_range *ranges, int entries) 268 { 269 size_t i; 270 const struct addr_range *ar; 271 272 for (i = 0; i < entries; ++i) { 273 ar = &ranges[i]; 274 275 if (s->addr >= ar->start && s->addr <= ar->end) 276 return 1; 277 } 278 279 return 0; 280 } 281 282 static int symbol_valid(const struct sym_entry *s) 283 { 284 const char *name = sym_name(s); 285 286 /* if --all-symbols is not specified, then symbols outside the text 287 * and inittext sections are discarded */ 288 if (!all_symbols) { 289 if (symbol_in_range(s, text_ranges, 290 ARRAY_SIZE(text_ranges)) == 0) 291 return 0; 292 /* Corner case. Discard any symbols with the same value as 293 * _etext _einittext; they can move between pass 1 and 2 when 294 * the kallsyms data are added. If these symbols move then 295 * they may get dropped in pass 2, which breaks the kallsyms 296 * rules. 297 */ 298 if ((s->addr == text_range_text->end && 299 strcmp(name, text_range_text->end_sym)) || 300 (s->addr == text_range_inittext->end && 301 strcmp(name, text_range_inittext->end_sym))) 302 return 0; 303 } 304 305 return 1; 306 } 307 308 /* remove all the invalid symbols from the table */ 309 static void shrink_table(void) 310 { 311 unsigned int i, pos; 312 313 pos = 0; 314 for (i = 0; i < table_cnt; i++) { 315 if (symbol_valid(table[i])) { 316 if (pos != i) 317 table[pos] = table[i]; 318 pos++; 319 } else { 320 free(table[i]); 321 } 322 } 323 table_cnt = pos; 324 325 /* When valid symbol is not registered, exit to error */ 326 if (!table_cnt) { 327 fprintf(stderr, "No valid symbol.\n"); 328 exit(1); 329 } 330 } 331 332 static void read_map(const char *in) 333 { 334 FILE *fp; 335 struct sym_entry *sym; 336 337 fp = fopen(in, "r"); 338 if (!fp) { 339 perror(in); 340 exit(1); 341 } 342 343 while (!feof(fp)) { 344 sym = read_symbol(fp); 345 if (!sym) 346 continue; 347 348 sym->start_pos = table_cnt; 349 350 if (table_cnt >= table_size) { 351 table_size += 10000; 352 table = realloc(table, sizeof(*table) * table_size); 353 if (!table) { 354 fprintf(stderr, "out of memory\n"); 355 fclose(fp); 356 exit (1); 357 } 358 } 359 360 table[table_cnt++] = sym; 361 } 362 363 fclose(fp); 364 } 365 366 static void output_label(const char *label) 367 { 368 printf(".globl %s\n", label); 369 printf("\tALGN\n"); 370 printf("%s:\n", label); 371 } 372 373 /* Provide proper symbols relocatability by their '_text' relativeness. */ 374 static void output_address(unsigned long long addr) 375 { 376 if (_text <= addr) 377 printf("\tPTR\t_text + %#llx\n", addr - _text); 378 else 379 printf("\tPTR\t_text - %#llx\n", _text - addr); 380 } 381 382 /* uncompress a compressed symbol. When this function is called, the best table 383 * might still be compressed itself, so the function needs to be recursive */ 384 static int expand_symbol(const unsigned char *data, int len, char *result) 385 { 386 int c, rlen, total=0; 387 388 while (len) { 389 c = *data; 390 /* if the table holds a single char that is the same as the one 391 * we are looking for, then end the search */ 392 if (best_table[c][0]==c && best_table_len[c]==1) { 393 *result++ = c; 394 total++; 395 } else { 396 /* if not, recurse and expand */ 397 rlen = expand_symbol(best_table[c], best_table_len[c], result); 398 total += rlen; 399 result += rlen; 400 } 401 data++; 402 len--; 403 } 404 *result=0; 405 406 return total; 407 } 408 409 static int symbol_absolute(const struct sym_entry *s) 410 { 411 return s->percpu_absolute; 412 } 413 414 static char * s_name(char *buf) 415 { 416 /* Skip the symbol type */ 417 return buf + 1; 418 } 419 420 static void cleanup_symbol_name(char *s) 421 { 422 char *p; 423 424 if (!lto_clang) 425 return; 426 427 /* 428 * ASCII[.] = 2e 429 * ASCII[0-9] = 30,39 430 * ASCII[A-Z] = 41,5a 431 * ASCII[_] = 5f 432 * ASCII[a-z] = 61,7a 433 * 434 * As above, replacing '.' with '\0' does not affect the main sorting, 435 * but it helps us with subsorting. 436 */ 437 p = strchr(s, '.'); 438 if (p) 439 *p = '\0'; 440 } 441 442 static int compare_names(const void *a, const void *b) 443 { 444 int ret; 445 char sa_namebuf[KSYM_NAME_LEN]; 446 char sb_namebuf[KSYM_NAME_LEN]; 447 const struct sym_entry *sa = *(const struct sym_entry **)a; 448 const struct sym_entry *sb = *(const struct sym_entry **)b; 449 450 expand_symbol(sa->sym, sa->len, sa_namebuf); 451 expand_symbol(sb->sym, sb->len, sb_namebuf); 452 cleanup_symbol_name(s_name(sa_namebuf)); 453 cleanup_symbol_name(s_name(sb_namebuf)); 454 ret = strcmp(s_name(sa_namebuf), s_name(sb_namebuf)); 455 if (!ret) { 456 if (sa->addr > sb->addr) 457 return 1; 458 else if (sa->addr < sb->addr) 459 return -1; 460 461 /* keep old order */ 462 return (int)(sa->seq - sb->seq); 463 } 464 465 return ret; 466 } 467 468 static void sort_symbols_by_name(void) 469 { 470 qsort(table, table_cnt, sizeof(table[0]), compare_names); 471 } 472 473 static void write_src(void) 474 { 475 unsigned int i, k, off; 476 unsigned int best_idx[256]; 477 unsigned int *markers; 478 char buf[KSYM_NAME_LEN]; 479 480 printf("#include <asm/bitsperlong.h>\n"); 481 printf("#if BITS_PER_LONG == 64\n"); 482 printf("#define PTR .quad\n"); 483 printf("#define ALGN .balign 8\n"); 484 printf("#else\n"); 485 printf("#define PTR .long\n"); 486 printf("#define ALGN .balign 4\n"); 487 printf("#endif\n"); 488 489 printf("\t.section .rodata, \"a\"\n"); 490 491 if (!base_relative) 492 output_label("kallsyms_addresses"); 493 else 494 output_label("kallsyms_offsets"); 495 496 for (i = 0; i < table_cnt; i++) { 497 if (base_relative) { 498 /* 499 * Use the offset relative to the lowest value 500 * encountered of all relative symbols, and emit 501 * non-relocatable fixed offsets that will be fixed 502 * up at runtime. 503 */ 504 505 long long offset; 506 int overflow; 507 508 if (!absolute_percpu) { 509 offset = table[i]->addr - relative_base; 510 overflow = (offset < 0 || offset > UINT_MAX); 511 } else if (symbol_absolute(table[i])) { 512 offset = table[i]->addr; 513 overflow = (offset < 0 || offset > INT_MAX); 514 } else { 515 offset = relative_base - table[i]->addr - 1; 516 overflow = (offset < INT_MIN || offset >= 0); 517 } 518 if (overflow) { 519 fprintf(stderr, "kallsyms failure: " 520 "%s symbol value %#llx out of range in relative mode\n", 521 symbol_absolute(table[i]) ? "absolute" : "relative", 522 table[i]->addr); 523 exit(EXIT_FAILURE); 524 } 525 expand_symbol(table[i]->sym, table[i]->len, buf); 526 printf("\t.long\t%#x /* %s */\n", (int)offset, buf); 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