1 /* Print size information from ELF file. 2 Copyright (C) 2000-2007,2009,2012 Red Hat, Inc. 3 This file is part of Red Hat elfutils. 4 Written by Ulrich Drepper <drepper (at) redhat.com>, 2000. 5 6 Red Hat elfutils is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by the 8 Free Software Foundation; version 2 of the License. 9 10 Red Hat elfutils is distributed in the hope that it will be useful, but 11 WITHOUT ANY WARRANTY; without even the implied warranty of 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 General Public License for more details. 14 15 You should have received a copy of the GNU General Public License along 16 with Red Hat elfutils; if not, write to the Free Software Foundation, 17 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA. 18 19 Red Hat elfutils is an included package of the Open Invention Network. 20 An included package of the Open Invention Network is a package for which 21 Open Invention Network licensees cross-license their patents. No patent 22 license is granted, either expressly or impliedly, by designation as an 23 included package. Should you wish to participate in the Open Invention 24 Network licensing program, please visit www.openinventionnetwork.com 25 <http://www.openinventionnetwork.com>. */ 26 27 #ifdef HAVE_CONFIG_H 28 # include <config.h> 29 #endif 30 31 #include <argp.h> 32 #include <error.h> 33 #include <fcntl.h> 34 #include <gelf.h> 35 #include <inttypes.h> 36 #include <libelf.h> 37 #include <libintl.h> 38 #include <locale.h> 39 #include <mcheck.h> 40 #include <stdbool.h> 41 #include <stdio.h> 42 #include <stdio_ext.h> 43 #include <stdlib.h> 44 #include <string.h> 45 #include <unistd.h> 46 #include <sys/param.h> 47 48 #include <system.h> 49 50 51 /* Name and version of program. */ 52 static void print_version (FILE *stream, struct argp_state *state); 53 ARGP_PROGRAM_VERSION_HOOK_DEF = print_version; 54 55 /* Bug report address. */ 56 ARGP_PROGRAM_BUG_ADDRESS_DEF = PACKAGE_BUGREPORT; 57 58 59 /* Values for the parameters which have no short form. */ 60 #define OPT_FORMAT 0x100 61 #define OPT_RADIX 0x101 62 63 /* Definitions of arguments for argp functions. */ 64 static const struct argp_option options[] = 65 { 66 { NULL, 0, NULL, 0, N_("Output format:"), 0 }, 67 { "format", OPT_FORMAT, "FORMAT", 0, 68 N_("Use the output format FORMAT. FORMAT can be `bsd' or `sysv'. " 69 "The default is `bsd'"), 0 }, 70 { NULL, 'A', NULL, 0, N_("Same as `--format=sysv'"), 0 }, 71 { NULL, 'B', NULL, 0, N_("Same as `--format=bsd'"), 0 }, 72 { "radix", OPT_RADIX, "RADIX", 0, N_("Use RADIX for printing symbol values"), 73 0}, 74 { NULL, 'd', NULL, 0, N_("Same as `--radix=10'"), 0 }, 75 { NULL, 'o', NULL, 0, N_("Same as `--radix=8'"), 0 }, 76 { NULL, 'x', NULL, 0, N_("Same as `--radix=16'"), 0 }, 77 { NULL, 'f', NULL, 0, 78 N_("Similar to `--format=sysv' output but in one line"), 0 }, 79 80 { NULL, 0, NULL, 0, N_("Output options:"), 0 }, 81 { NULL, 'F', NULL, 0, 82 N_("Print size and permission flags for loadable segments"), 0 }, 83 { "totals", 't', NULL, 0, N_("Display the total sizes (bsd only)"), 0 }, 84 { NULL, 0, NULL, 0, NULL, 0 } 85 }; 86 87 /* Short description of program. */ 88 static const char doc[] = N_("\ 89 List section sizes of FILEs (a.out by default)."); 90 91 /* Strings for arguments in help texts. */ 92 static const char args_doc[] = N_("[FILE...]"); 93 94 /* Prototype for option handler. */ 95 static error_t parse_opt (int key, char *arg, struct argp_state *state); 96 97 /* Data structure to communicate with argp functions. */ 98 static struct argp argp = 99 { 100 options, parse_opt, args_doc, doc, NULL, NULL, NULL 101 }; 102 103 104 /* Print symbols in file named FNAME. */ 105 static int process_file (const char *fname); 106 107 /* Handle content of archive. */ 108 static int handle_ar (int fd, Elf *elf, const char *prefix, const char *fname); 109 110 /* Handle ELF file. */ 111 static void handle_elf (Elf *elf, const char *fullname, const char *fname); 112 113 /* Show total size. */ 114 static void show_bsd_totals (void); 115 116 #define INTERNAL_ERROR(fname) \ 117 error (EXIT_FAILURE, 0, gettext ("%s: INTERNAL ERROR %d (%s-%s): %s"), \ 118 fname, __LINE__, PACKAGE_VERSION, __DATE__, elf_errmsg (-1)) 119 120 121 /* User-selectable options. */ 122 123 /* The selected output format. */ 124 static enum 125 { 126 format_bsd = 0, 127 format_sysv, 128 format_sysv_one_line, 129 format_segments 130 } format; 131 132 /* Radix for printed numbers. */ 133 static enum 134 { 135 radix_decimal = 0, 136 radix_hex, 137 radix_octal 138 } radix; 139 140 141 /* Mapping of radix and binary class to length. */ 142 static const int length_map[2][3] = 143 { 144 [ELFCLASS32 - 1] = 145 { 146 [radix_hex] = 8, 147 [radix_decimal] = 10, 148 [radix_octal] = 11 149 }, 150 [ELFCLASS64 - 1] = 151 { 152 [radix_hex] = 16, 153 [radix_decimal] = 20, 154 [radix_octal] = 22 155 } 156 }; 157 158 /* True if total sizes should be printed. */ 159 static bool totals; 160 /* To print the total sizes in a reasonable format remember the higest 161 "class" of ELF binaries processed. */ 162 static int totals_class; 163 164 165 int 166 main (int argc, char *argv[]) 167 { 168 int remaining; 169 int result = 0; 170 171 /* Make memory leak detection possible. */ 172 mtrace (); 173 174 /* We use no threads here which can interfere with handling a stream. */ 175 __fsetlocking (stdin, FSETLOCKING_BYCALLER); 176 __fsetlocking (stdout, FSETLOCKING_BYCALLER); 177 __fsetlocking (stderr, FSETLOCKING_BYCALLER); 178 179 /* Set locale. */ 180 setlocale (LC_ALL, ""); 181 182 /* Make sure the message catalog can be found. */ 183 bindtextdomain (PACKAGE_TARNAME, LOCALEDIR); 184 185 /* Initialize the message catalog. */ 186 textdomain (PACKAGE_TARNAME); 187 188 /* Parse and process arguments. */ 189 argp_parse (&argp, argc, argv, 0, &remaining, NULL); 190 191 192 /* Tell the library which version we are expecting. */ 193 elf_version (EV_CURRENT); 194 195 if (remaining == argc) 196 /* The user didn't specify a name so we use a.out. */ 197 result = process_file ("a.out"); 198 else 199 /* Process all the remaining files. */ 200 do 201 result |= process_file (argv[remaining]); 202 while (++remaining < argc); 203 204 /* Print the total sizes but only if the output format is BSD and at 205 least one file has been correctly read (i.e., we recognized the 206 class). */ 207 if (totals && format == format_bsd && totals_class != 0) 208 show_bsd_totals (); 209 210 return result; 211 } 212 213 214 /* Print the version information. */ 215 static void 216 print_version (FILE *stream, struct argp_state *state __attribute__ ((unused))) 217 { 218 fprintf (stream, "size (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION); 219 fprintf (stream, gettext ("\ 220 Copyright (C) %s Red Hat, Inc.\n\ 221 This is free software; see the source for copying conditions. There is NO\n\ 222 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\ 223 "), "2012"); 224 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper"); 225 } 226 227 228 /* Handle program arguments. */ 229 static error_t 230 parse_opt (int key, char *arg, 231 struct argp_state *state __attribute__ ((unused))) 232 { 233 switch (key) 234 { 235 case 'd': 236 radix = radix_decimal; 237 break; 238 239 case 'f': 240 format = format_sysv_one_line; 241 break; 242 243 case 'o': 244 radix = radix_octal; 245 break; 246 247 case 'x': 248 radix = radix_hex; 249 break; 250 251 case 'A': 252 format = format_sysv; 253 break; 254 255 case 'B': 256 format = format_bsd; 257 break; 258 259 case 'F': 260 format = format_segments; 261 break; 262 263 case OPT_FORMAT: 264 if (strcmp (arg, "bsd") == 0 || strcmp (arg, "berkeley") == 0) 265 format = format_bsd; 266 else if (likely (strcmp (arg, "sysv") == 0)) 267 format = format_sysv; 268 else 269 error (EXIT_FAILURE, 0, gettext ("Invalid format: %s"), arg); 270 break; 271 272 case OPT_RADIX: 273 if (strcmp (arg, "x") == 0 || strcmp (arg, "16") == 0) 274 radix = radix_hex; 275 else if (strcmp (arg, "d") == 0 || strcmp (arg, "10") == 0) 276 radix = radix_decimal; 277 else if (strcmp (arg, "o") == 0 || strcmp (arg, "8") == 0) 278 radix = radix_octal; 279 else 280 error (EXIT_FAILURE, 0, gettext ("Invalid radix: %s"), arg); 281 break; 282 283 case 't': 284 totals = true; 285 break; 286 287 default: 288 return ARGP_ERR_UNKNOWN; 289 } 290 return 0; 291 } 292 293 294 /* Open the file and determine the type. */ 295 static int 296 process_file (const char *fname) 297 { 298 int fd = open (fname, O_RDONLY); 299 if (unlikely (fd == -1)) 300 { 301 error (0, errno, gettext ("cannot open '%s'"), fname); 302 return 1; 303 } 304 305 /* Now get the ELF descriptor. */ 306 Elf *elf = elf_begin (fd, ELF_C_READ_MMAP, NULL); 307 if (likely (elf != NULL)) 308 { 309 if (elf_kind (elf) == ELF_K_ELF) 310 { 311 handle_elf (elf, NULL, fname); 312 313 if (unlikely (elf_end (elf) != 0)) 314 INTERNAL_ERROR (fname); 315 316 if (unlikely (close (fd) != 0)) 317 error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname); 318 319 return 0; 320 } 321 else if (likely (elf_kind (elf) == ELF_K_AR)) 322 { 323 int result = handle_ar (fd, elf, NULL, fname); 324 325 if (unlikely (close (fd) != 0)) 326 error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname); 327 328 return result; 329 } 330 331 /* We cannot handle this type. Close the descriptor anyway. */ 332 if (unlikely (elf_end (elf) != 0)) 333 INTERNAL_ERROR (fname); 334 } 335 336 if (unlikely (close (fd) != 0)) 337 error (EXIT_FAILURE, errno, gettext ("while closing '%s'"), fname); 338 339 error (0, 0, gettext ("%s: file format not recognized"), fname); 340 341 return 1; 342 } 343 344 345 /* Print the BSD-style header. This is done exactly once. */ 346 static void 347 print_header (Elf *elf) 348 { 349 static int done; 350 351 if (! done) 352 { 353 int ddigits = length_map[gelf_getclass (elf) - 1][radix_decimal]; 354 int xdigits = length_map[gelf_getclass (elf) - 1][radix_hex]; 355 356 printf ("%*s %*s %*s %*s %*s %s\n", 357 ddigits - 2, sgettext ("bsd|text"), 358 ddigits - 2, sgettext ("bsd|data"), 359 ddigits - 2, sgettext ("bsd|bss"), 360 ddigits - 2, sgettext ("bsd|dec"), 361 xdigits - 2, sgettext ("bsd|hex"), 362 sgettext ("bsd|filename")); 363 364 done = 1; 365 } 366 } 367 368 369 static int 370 handle_ar (int fd, Elf *elf, const char *prefix, const char *fname) 371 { 372 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix); 373 size_t fname_len = strlen (fname) + 1; 374 char new_prefix[prefix_len + 1 + fname_len]; 375 char *cp = new_prefix; 376 377 /* Create the full name of the file. */ 378 if (prefix != NULL) 379 { 380 cp = mempcpy (cp, prefix, prefix_len); 381 *cp++ = ':'; 382 } 383 memcpy (cp, fname, fname_len); 384 385 /* Process all the files contained in the archive. */ 386 int result = 0; 387 Elf *subelf; 388 Elf_Cmd cmd = ELF_C_READ_MMAP; 389 while ((subelf = elf_begin (fd, cmd, elf)) != NULL) 390 { 391 /* The the header for this element. */ 392 Elf_Arhdr *arhdr = elf_getarhdr (subelf); 393 394 if (elf_kind (subelf) == ELF_K_ELF) 395 handle_elf (subelf, new_prefix, arhdr->ar_name); 396 else if (likely (elf_kind (subelf) == ELF_K_AR)) 397 result |= handle_ar (fd, subelf, new_prefix, arhdr->ar_name); 398 /* else signal error??? */ 399 400 /* Get next archive element. */ 401 cmd = elf_next (subelf); 402 if (unlikely (elf_end (subelf) != 0)) 403 INTERNAL_ERROR (fname); 404 } 405 406 if (unlikely (elf_end (elf) != 0)) 407 INTERNAL_ERROR (fname); 408 409 return result; 410 } 411 412 413 /* Show sizes in SysV format. */ 414 static void 415 show_sysv (Elf *elf, const char *prefix, const char *fname, 416 const char *fullname) 417 { 418 int maxlen = 10; 419 const int digits = length_map[gelf_getclass (elf) - 1][radix]; 420 421 /* Get the section header string table index. */ 422 size_t shstrndx; 423 if (unlikely (elf_getshdrstrndx (elf, &shstrndx) < 0)) 424 error (EXIT_FAILURE, 0, 425 gettext ("cannot get section header string table index")); 426 427 /* First round over the sections: determine the longest section name. */ 428 Elf_Scn *scn = NULL; 429 while ((scn = elf_nextscn (elf, scn)) != NULL) 430 { 431 GElf_Shdr shdr_mem; 432 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 433 434 if (shdr == NULL) 435 INTERNAL_ERROR (fullname); 436 437 /* Ignore all sections which are not used at runtime. */ 438 if ((shdr->sh_flags & SHF_ALLOC) != 0) 439 maxlen = MAX (maxlen, 440 (int) strlen (elf_strptr (elf, shstrndx, 441 shdr->sh_name))); 442 } 443 444 fputs_unlocked (fname, stdout); 445 if (prefix != NULL) 446 printf (gettext (" (ex %s)"), prefix); 447 printf (":\n%-*s %*s %*s\n", 448 maxlen, sgettext ("sysv|section"), 449 digits - 2, sgettext ("sysv|size"), 450 digits, sgettext ("sysv|addr")); 451 452 const char *fmtstr; 453 if (radix == radix_hex) 454 fmtstr = "%-*s %*" PRIx64 " %*" PRIx64 "\n"; 455 else if (radix == radix_decimal) 456 fmtstr = "%-*s %*" PRId64 " %*" PRId64 "\n"; 457 else 458 fmtstr = "%-*s %*" PRIo64 " %*" PRIo64 "\n"; 459 460 /* Iterate over all sections. */ 461 GElf_Off total = 0; 462 while ((scn = elf_nextscn (elf, scn)) != NULL) 463 { 464 GElf_Shdr shdr_mem; 465 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 466 467 /* Ignore all sections which are not used at runtime. */ 468 if ((shdr->sh_flags & SHF_ALLOC) != 0) 469 { 470 printf (fmtstr, 471 maxlen, elf_strptr (elf, shstrndx, shdr->sh_name), 472 digits - 2, shdr->sh_size, 473 digits, shdr->sh_addr); 474 475 total += shdr->sh_size; 476 } 477 } 478 479 if (radix == radix_hex) 480 printf ("%-*s %*" PRIx64 "\n\n\n", maxlen, sgettext ("sysv|Total"), 481 digits - 2, total); 482 else if (radix == radix_decimal) 483 printf ("%-*s %*" PRId64 "\n\n\n", maxlen, sgettext ("sysv|Total"), 484 digits - 2, total); 485 else 486 printf ("%-*s %*" PRIo64 "\n\n\n", maxlen, sgettext ("sysv|Total"), 487 digits - 2, total); 488 } 489 490 491 /* Show sizes in SysV format in one line. */ 492 static void 493 show_sysv_one_line (Elf *elf) 494 { 495 /* Get the section header string table index. */ 496 size_t shstrndx; 497 if (unlikely (elf_getshdrstrndx (elf, &shstrndx) < 0)) 498 error (EXIT_FAILURE, 0, 499 gettext ("cannot get section header string table index")); 500 501 const char *fmtstr; 502 if (radix == radix_hex) 503 fmtstr = "%" PRIx64 "(%s)"; 504 else if (radix == radix_decimal) 505 fmtstr = "%" PRId64 "(%s)"; 506 else 507 fmtstr = "%" PRIo64 "(%s)"; 508 509 /* Iterate over all sections. */ 510 GElf_Off total = 0; 511 bool first = true; 512 Elf_Scn *scn = NULL; 513 while ((scn = elf_nextscn (elf, scn)) != NULL) 514 { 515 GElf_Shdr shdr_mem; 516 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 517 518 /* Ignore all sections which are not used at runtime. */ 519 if ((shdr->sh_flags & SHF_ALLOC) == 0) 520 continue; 521 522 if (! first) 523 fputs_unlocked (" + ", stdout); 524 first = false; 525 526 printf (fmtstr, shdr->sh_size, 527 elf_strptr (elf, shstrndx, shdr->sh_name)); 528 529 total += shdr->sh_size; 530 } 531 532 if (radix == radix_hex) 533 printf (" = %#" PRIx64 "\n", total); 534 else if (radix == radix_decimal) 535 printf (" = %" PRId64 "\n", total); 536 else 537 printf (" = %" PRIo64 "\n", total); 538 } 539 540 541 /* Variables to add up the sizes of all files. */ 542 static uintmax_t total_textsize; 543 static uintmax_t total_datasize; 544 static uintmax_t total_bsssize; 545 546 547 /* Show sizes in BSD format. */ 548 static void 549 show_bsd (Elf *elf, const char *prefix, const char *fname, 550 const char *fullname) 551 { 552 GElf_Off textsize = 0; 553 GElf_Off datasize = 0; 554 GElf_Off bsssize = 0; 555 const int ddigits = length_map[gelf_getclass (elf) - 1][radix_decimal]; 556 const int xdigits = length_map[gelf_getclass (elf) - 1][radix_hex]; 557 558 /* Iterate over all sections. */ 559 Elf_Scn *scn = NULL; 560 while ((scn = elf_nextscn (elf, scn)) != NULL) 561 { 562 GElf_Shdr shdr_mem; 563 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 564 565 if (shdr == NULL) 566 INTERNAL_ERROR (fullname); 567 568 /* Ignore all sections which are not marked as loaded. */ 569 if ((shdr->sh_flags & SHF_ALLOC) == 0) 570 continue; 571 572 if ((shdr->sh_flags & SHF_WRITE) == 0) 573 textsize += shdr->sh_size; 574 else if (shdr->sh_type == SHT_NOBITS) 575 bsssize += shdr->sh_size; 576 else 577 datasize += shdr->sh_size; 578 } 579 580 printf ("%*" PRId64 " %*" PRId64 " %*" PRId64 " %*" PRId64 " %*" 581 PRIx64 " %s", 582 ddigits - 2, textsize, 583 ddigits - 2, datasize, 584 ddigits - 2, bsssize, 585 ddigits - 2, textsize + datasize + bsssize, 586 xdigits - 2, textsize + datasize + bsssize, 587 fname); 588 if (prefix != NULL) 589 printf (gettext (" (ex %s)"), prefix); 590 fputs_unlocked ("\n", stdout); 591 592 total_textsize += textsize; 593 total_datasize += datasize; 594 total_bsssize += bsssize; 595 596 totals_class = MAX (totals_class, gelf_getclass (elf)); 597 } 598 599 600 /* Show total size. */ 601 static void 602 show_bsd_totals (void) 603 { 604 int ddigits = length_map[totals_class - 1][radix_decimal]; 605 int xdigits = length_map[totals_class - 1][radix_hex]; 606 607 printf ("%*" PRIuMAX " %*" PRIuMAX " %*" PRIuMAX " %*" PRIuMAX " %*" 608 PRIxMAX " %s", 609 ddigits - 2, total_textsize, 610 ddigits - 2, total_datasize, 611 ddigits - 2, total_bsssize, 612 ddigits - 2, total_textsize + total_datasize + total_bsssize, 613 xdigits - 2, total_textsize + total_datasize + total_bsssize, 614 gettext ("(TOTALS)\n")); 615 } 616 617 618 /* Show size and permission of loadable segments. */ 619 static void 620 show_segments (Elf *elf, const char *fullname) 621 { 622 GElf_Ehdr ehdr_mem; 623 GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem); 624 if (ehdr == NULL) 625 INTERNAL_ERROR (fullname); 626 627 GElf_Off total = 0; 628 bool first = true; 629 for (size_t cnt = 0; cnt < ehdr->e_phnum; ++cnt) 630 { 631 GElf_Phdr phdr_mem; 632 GElf_Phdr *phdr; 633 634 phdr = gelf_getphdr (elf, cnt, &phdr_mem); 635 if (phdr == NULL) 636 INTERNAL_ERROR (fullname); 637 638 if (phdr->p_type != PT_LOAD) 639 /* Only load segments. */ 640 continue; 641 642 if (! first) 643 fputs_unlocked (" + ", stdout); 644 first = false; 645 646 printf (radix == radix_hex ? "%" PRIx64 "(%c%c%c)" 647 : (radix == radix_decimal ? "%" PRId64 "(%c%c%c)" 648 : "%" PRIo64 "(%c%c%c)"), 649 phdr->p_memsz, 650 (phdr->p_flags & PF_R) == 0 ? '-' : 'r', 651 (phdr->p_flags & PF_W) == 0 ? '-' : 'w', 652 (phdr->p_flags & PF_X) == 0 ? '-' : 'x'); 653 654 total += phdr->p_memsz; 655 } 656 657 if (radix == radix_hex) 658 printf (" = %#" PRIx64 "\n", total); 659 else if (radix == radix_decimal) 660 printf (" = %" PRId64 "\n", total); 661 else 662 printf (" = %" PRIo64 "\n", total); 663 } 664 665 666 static void 667 handle_elf (Elf *elf, const char *prefix, const char *fname) 668 { 669 size_t prefix_len = prefix == NULL ? 0 : strlen (prefix); 670 size_t fname_len = strlen (fname) + 1; 671 char fullname[prefix_len + 1 + fname_len]; 672 char *cp = fullname; 673 674 /* Create the full name of the file. */ 675 if (prefix != NULL) 676 { 677 cp = mempcpy (cp, prefix, prefix_len); 678 *cp++ = ':'; 679 } 680 memcpy (cp, fname, fname_len); 681 682 if (format == format_sysv) 683 show_sysv (elf, prefix, fname, fullname); 684 else if (format == format_sysv_one_line) 685 show_sysv_one_line (elf); 686 else if (format == format_segments) 687 show_segments (elf, fullname); 688 else 689 { 690 print_header (elf); 691 692 show_bsd (elf, prefix, fname, fullname); 693 } 694 } 695 696 697 #include "debugpred.h" 698
