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