2007-01-29 14:18:46 +01:00
|
|
|
/*
|
2006-10-25 17:49:47 +02:00
|
|
|
Copyright (C) 2006 Mandriva Conectiva S.A.
|
|
|
|
Copyright (C) 2006 Arnaldo Carvalho de Melo <acme@mandriva.com>
|
2007-01-29 14:18:46 +01:00
|
|
|
Copyright (C) 2007 Arnaldo Carvalho de Melo <acme@redhat.com>
|
2006-10-25 17:49:47 +02:00
|
|
|
|
2006-10-25 01:42:39 +02:00
|
|
|
This program is free software; you can redistribute it and/or modify it
|
|
|
|
under the terms of version 2 of the GNU General Public License as
|
|
|
|
published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
2007-03-30 15:07:01 +02:00
|
|
|
#include <argp.h>
|
2006-10-25 01:42:39 +02:00
|
|
|
#include <stdio.h>
|
2006-10-28 23:22:42 +02:00
|
|
|
#include <dwarf.h>
|
2006-12-18 13:47:39 +01:00
|
|
|
#include <stdarg.h>
|
2006-10-25 01:42:39 +02:00
|
|
|
#include <stdlib.h>
|
2006-11-11 17:15:50 +01:00
|
|
|
#include <string.h>
|
2006-10-25 01:42:39 +02:00
|
|
|
|
2007-01-11 19:07:05 +01:00
|
|
|
#include "dwarves.h"
|
2006-10-25 01:42:39 +02:00
|
|
|
|
2007-01-28 14:07:22 +01:00
|
|
|
static uint8_t class__include_anonymous;
|
|
|
|
static uint8_t class__include_nested_anonymous;
|
|
|
|
|
2006-12-01 02:23:41 +01:00
|
|
|
static char *class__exclude_prefix;
|
|
|
|
static size_t class__exclude_prefix_len;
|
2006-12-01 02:12:21 +01:00
|
|
|
|
2006-12-01 02:36:55 +01:00
|
|
|
static char *cu__exclude_prefix;
|
|
|
|
static size_t cu__exclude_prefix_len;
|
|
|
|
|
2006-12-01 03:08:10 +01:00
|
|
|
static char *decl_exclude_prefix;
|
|
|
|
static size_t decl_exclude_prefix_len;
|
|
|
|
|
2006-12-28 14:18:43 +01:00
|
|
|
static uint16_t nr_holes;
|
|
|
|
static uint16_t nr_bit_holes;
|
2006-12-18 19:27:14 +01:00
|
|
|
static uint8_t show_packable;
|
[PAHOLE]: Reorganize bitfields
This cset also does a fixup for cases where the compiler keeps the type
specified by the programmer for a bitfield but uses less space to combine with
the next, non-bitfield member, these cases can be caught using plain pahole and
will appear with this comment:
/* --- cacheline 1 boundary (64 bytes) --- */
int bitfield1:1; /* 64 4 */
int bitfield2:1; /* 64 4 */
/* XXX 14 bits hole, try to pack */
/* Bitfield WARNING: DWARF size=4, real size=2 */
short int d; /* 66 2 */
The fixup is done prior to reorganizing the fields.
Now an example of this code in action:
[acme@filo examples]$ cat swiss_cheese.c
<SNIP>
struct cheese {
char id;
short number;
char name[52];
int a:1;
int b;
int bitfield1:1;
int bitfield2:1;
short d;
short e;
short last:5;
};
<SNIP>
[acme@filo examples]$
Lets look at the layout:
[acme@filo examples]$ pahole swiss_cheese cheese
/* <11b> /home/acme/git/pahole/examples/swiss_cheese.c:3 */
struct cheese {
char id; /* 0 1 */
/* XXX 1 byte hole, try to pack */
short int number; /* 2 2 */
char name[52]; /* 4 52 */
int a:1; /* 56 4 */
/* XXX 31 bits hole, try to pack */
int b; /* 60 4 */
/* --- cacheline 1 boundary (64 bytes) --- */
int bitfield1:1; /* 64 4 */
int bitfield2:1; /* 64 4 */
/* XXX 14 bits hole, try to pack */
/* Bitfield WARNING: DWARF size=4, real size=2 */
short int d; /* 66 2 */
short int e; /* 68 2 */
short int last:5; /* 70 2 */
}; /* size: 72, cachelines: 2 */
/* sum members: 71, holes: 1, sum holes: 1 */
/* bit holes: 2, sum bit holes: 45 bits */
/* bit_padding: 11 bits */
/* last cacheline: 8 bytes */
[acme@filo examples]$
Full of holes, has bit padding and uses more than one 64 bytes cacheline.
Now lets ask pahole to reorganize it:
[acme@filo examples]$ pahole --reorganize --verbose swiss_cheese cheese
/* Demoting bitfield ('a' ... 'a') from 'int' to 'unsigned char' */
/* Demoting bitfield ('bitfield1' ... 'bitfield2') from 'short unsigned int' to 'unsigned char' */
/* Demoting bitfield ('last') from 'short int' to 'unsigned char' */
/* Moving 'bitfield2:1' from after 'bitfield1' to after 'a:1' */
/* Moving 'bitfield1:1' from after 'b' to after 'bitfield2:1' */
/* Moving 'last:5' from after 'e' to after 'bitfield1:1' */
/* Moving bitfield('a' ... 'last') from after 'name' to after 'id' */
/* Moving 'e' from after 'd' to after 'b' */
/* <11b> /home/acme/git/pahole/examples/swiss_cheese.c:3 */
struct cheese {
char id; /* 0 1 */
unsigned char a:1; /* 1 1 */
unsigned char bitfield2:1; /* 1 1 */
unsigned char bitfield1:1; /* 1 1 */
unsigned char last:5; /* 1 1 */
short int number; /* 2 2 */
char name[52]; /* 4 52 */
int b; /* 56 4 */
short int e; /* 60 2 */
short int d; /* 62 2 */
/* --- cacheline 1 boundary (64 bytes) --- */
}; /* size: 64, cachelines: 1 */
/* saved 8 bytes and 1 cacheline! */
[acme@filo examples]$
Instant karma, it gets completely packed, and look ma, no
__attribute__((packed)) :-)
With this struct task_struct in the linux kernel is shrunk by 12 bytes, there
is more 4 bytes to save with another technique that involves not combining
holes, but using the last single hole to fill it with members at the tail of
the struct.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2007-02-01 13:51:16 +01:00
|
|
|
static uint8_t global_verbose;
|
2007-01-29 16:12:23 +01:00
|
|
|
static uint8_t expand_types;
|
2007-03-30 15:07:01 +02:00
|
|
|
static size_t cacheline_size;
|
|
|
|
static int reorganize;
|
|
|
|
static int show_reorg_steps;
|
2006-12-07 19:14:15 +01:00
|
|
|
|
2006-11-04 00:24:37 +01:00
|
|
|
struct structure {
|
|
|
|
struct list_head node;
|
|
|
|
const struct class *class;
|
2007-01-04 04:41:11 +01:00
|
|
|
const struct cu *cu;
|
2006-12-28 14:18:43 +01:00
|
|
|
uint32_t nr_files;
|
2007-01-13 16:59:32 +01:00
|
|
|
uint32_t nr_methods;
|
2006-11-04 00:24:37 +01:00
|
|
|
};
|
|
|
|
|
2007-01-04 04:41:11 +01:00
|
|
|
static struct structure *structure__new(const struct class *class,
|
|
|
|
const struct cu *cu)
|
2006-11-04 00:24:37 +01:00
|
|
|
{
|
|
|
|
struct structure *self = malloc(sizeof(*self));
|
|
|
|
|
|
|
|
if (self != NULL) {
|
2007-01-13 16:59:32 +01:00
|
|
|
self->class = class;
|
|
|
|
self->cu = cu;
|
|
|
|
self->nr_files = 1;
|
|
|
|
self->nr_methods = 0;
|
2006-11-04 00:24:37 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
static LIST_HEAD(structures__list);
|
|
|
|
|
|
|
|
static struct structure *structures__find(const char *name)
|
|
|
|
{
|
|
|
|
struct structure *pos;
|
|
|
|
|
2007-01-28 14:07:22 +01:00
|
|
|
if (name == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
list_for_each_entry(pos, &structures__list, node) {
|
|
|
|
const char *class_name = class__name(pos->class);
|
|
|
|
|
|
|
|
if (class_name != NULL &&
|
|
|
|
strcmp(class__name(pos->class), name) == 0)
|
2006-11-04 00:24:37 +01:00
|
|
|
return pos;
|
2007-01-28 14:07:22 +01:00
|
|
|
}
|
|
|
|
|
2006-11-04 00:24:37 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-01-04 04:41:11 +01:00
|
|
|
static void structures__add(const struct class *class, const struct cu *cu)
|
2006-11-04 00:24:37 +01:00
|
|
|
{
|
2007-01-04 04:41:11 +01:00
|
|
|
struct structure *str = structure__new(class, cu);
|
2006-11-04 00:24:37 +01:00
|
|
|
|
2006-12-18 13:47:39 +01:00
|
|
|
if (str != NULL)
|
|
|
|
list_add(&str->node, &structures__list);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void nr_definitions_formatter(const struct structure *self)
|
|
|
|
{
|
2007-01-07 15:30:58 +01:00
|
|
|
printf("%s: %u\n", class__name(self->class), self->nr_files);
|
2006-11-04 00:24:37 +01:00
|
|
|
}
|
|
|
|
|
2006-12-18 13:47:39 +01:00
|
|
|
static void nr_members_formatter(const struct structure *self)
|
2006-11-04 00:24:37 +01:00
|
|
|
{
|
2007-01-09 13:00:47 +01:00
|
|
|
printf("%s: %u\n", class__name(self->class),
|
|
|
|
class__nr_members(self->class));
|
2006-11-04 00:24:37 +01:00
|
|
|
}
|
|
|
|
|
2007-01-13 16:59:32 +01:00
|
|
|
static void nr_methods_formatter(const struct structure *self)
|
|
|
|
{
|
|
|
|
printf("%s: %u\n", class__name(self->class), self->nr_methods);
|
|
|
|
}
|
|
|
|
|
2006-12-18 13:47:39 +01:00
|
|
|
static void size_formatter(const struct structure *self)
|
|
|
|
{
|
2007-03-28 16:38:32 +02:00
|
|
|
printf("%s: %zd %u\n", class__name(self->class),
|
2007-01-09 13:00:47 +01:00
|
|
|
class__size(self->class), self->class->nr_holes);
|
2006-12-18 13:47:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void class_name_len_formatter(const struct structure *self)
|
|
|
|
{
|
2007-01-07 15:30:58 +01:00
|
|
|
const char *name = class__name(self->class);
|
2007-03-28 16:38:32 +02:00
|
|
|
printf("%s: %zd\n", name, strlen(name));
|
2006-12-18 13:47:39 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void class_formatter(const struct structure *self)
|
|
|
|
{
|
2007-01-28 14:07:22 +01:00
|
|
|
struct tag *typedef_alias = NULL;
|
|
|
|
struct tag *tag = class__tag(self->class);
|
|
|
|
const char *name = class__name(self->class);
|
|
|
|
|
|
|
|
if (name == NULL) {
|
|
|
|
/*
|
|
|
|
* Find the first typedef for this struct, this is enough
|
|
|
|
* as if we optimize the struct all the typedefs will be
|
|
|
|
* affected.
|
|
|
|
*/
|
|
|
|
typedef_alias = cu__find_first_typedef_of_type(self->cu,
|
|
|
|
tag->id);
|
|
|
|
/*
|
|
|
|
* If there is no typedefs for this anonymous struct it is
|
|
|
|
* found just inside another struct, and in this case it'll
|
|
|
|
* be printed when the type it is in is printed, but if
|
|
|
|
* the user still wants to see its statistics, just use
|
|
|
|
* --nested_anon_include.
|
|
|
|
*/
|
|
|
|
if (typedef_alias == NULL && !class__include_nested_anonymous)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (typedef_alias != NULL) {
|
|
|
|
const struct type *tdef = tag__type(typedef_alias);
|
2007-02-15 14:40:51 +01:00
|
|
|
tag__fprintf(tag, self->cu, "typedef", tdef->name,
|
|
|
|
expand_types, stdout);
|
2007-01-28 14:07:22 +01:00
|
|
|
} else
|
2007-02-15 14:40:51 +01:00
|
|
|
tag__fprintf(tag, self->cu, NULL, NULL, expand_types, stdout);
|
2007-01-28 14:07:22 +01:00
|
|
|
|
2006-12-18 13:47:39 +01:00
|
|
|
printf(" /* definitions: %u */\n", self->nr_files);
|
|
|
|
putchar('\n');
|
|
|
|
}
|
|
|
|
|
|
|
|
static void print_classes(void (*formatter)(const struct structure *s))
|
2006-11-04 00:24:37 +01:00
|
|
|
{
|
|
|
|
struct structure *pos;
|
|
|
|
|
|
|
|
list_for_each_entry(pos, &structures__list, node)
|
2007-04-01 15:03:04 +02:00
|
|
|
if (show_packable && !global_verbose) {
|
|
|
|
const struct class *c = pos->class;
|
2007-04-02 15:12:09 +02:00
|
|
|
const size_t orig_size = class__size(c);
|
|
|
|
const size_t new_size = class__size(c->priv);
|
|
|
|
const size_t savings = orig_size - new_size;
|
2007-04-03 14:11:06 +02:00
|
|
|
printf("%-32s %5zd %5zd %5zd\n",
|
|
|
|
class__name(c), orig_size, new_size, savings);
|
2007-04-01 15:03:04 +02:00
|
|
|
} else
|
|
|
|
formatter(pos);
|
2006-11-04 00:24:37 +01:00
|
|
|
}
|
|
|
|
|
2006-12-05 17:58:27 +01:00
|
|
|
static struct cu *cu__filter(struct cu *cu)
|
2006-12-01 02:36:55 +01:00
|
|
|
{
|
|
|
|
if (cu__exclude_prefix != NULL &&
|
|
|
|
(cu->name == NULL ||
|
|
|
|
strncmp(cu__exclude_prefix, cu->name,
|
|
|
|
cu__exclude_prefix_len) == 0))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return cu;
|
|
|
|
}
|
|
|
|
|
2007-04-01 15:03:04 +02:00
|
|
|
static int class__packable(struct class *self, const struct cu *cu)
|
2006-12-07 19:14:15 +01:00
|
|
|
{
|
2007-04-01 14:31:35 +02:00
|
|
|
struct class *clone;
|
|
|
|
size_t savings;
|
2006-12-07 19:14:15 +01:00
|
|
|
|
|
|
|
if (self->nr_holes == 0 && self->nr_bit_holes == 0)
|
|
|
|
return 0;
|
|
|
|
|
2007-04-01 14:31:35 +02:00
|
|
|
clone = class__clone(self, NULL);
|
|
|
|
if (clone == NULL)
|
|
|
|
return 0;
|
|
|
|
class__reorganize(clone, cu, 0, stdout);
|
|
|
|
savings = class__size(self) - class__size(clone);
|
2007-04-01 15:03:04 +02:00
|
|
|
if (savings != 0) {
|
|
|
|
self->priv = clone;
|
|
|
|
return 1;
|
|
|
|
}
|
2007-04-01 14:31:35 +02:00
|
|
|
class__delete(clone);
|
2007-04-01 15:03:04 +02:00
|
|
|
return 0;
|
2006-12-07 19:14:15 +01:00
|
|
|
}
|
|
|
|
|
2007-01-04 04:41:11 +01:00
|
|
|
static void class__dupmsg(const struct class *self, const struct cu *cu,
|
2007-01-29 13:42:03 +01:00
|
|
|
const struct class *dup __unused,
|
|
|
|
const struct cu *dup_cu,
|
2006-12-18 13:47:39 +01:00
|
|
|
char *hdr, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
if (!*hdr)
|
|
|
|
printf("class: %s\nfirst: %s\ncurrent: %s\n",
|
2007-01-07 15:30:58 +01:00
|
|
|
class__name(self), cu->name, dup_cu->name);
|
2007-01-29 14:18:46 +01:00
|
|
|
|
2006-12-18 13:47:39 +01:00
|
|
|
va_start(args, fmt);
|
|
|
|
vprintf(fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
*hdr = 1;
|
|
|
|
}
|
|
|
|
|
2007-01-04 04:41:11 +01:00
|
|
|
static void class__chkdupdef(const struct class *self, const struct cu *cu,
|
|
|
|
struct class *dup, const struct cu *dup_cu)
|
2006-12-18 13:47:39 +01:00
|
|
|
{
|
|
|
|
char hdr = 0;
|
|
|
|
|
2007-01-09 13:00:47 +01:00
|
|
|
if (class__size(self) != class__size(dup))
|
2007-01-04 04:41:11 +01:00
|
|
|
class__dupmsg(self, cu, dup, dup_cu,
|
|
|
|
&hdr, "size: %u != %u\n",
|
2007-01-09 13:00:47 +01:00
|
|
|
class__size(self), class__size(dup));
|
2006-12-18 13:47:39 +01:00
|
|
|
|
2007-01-09 13:00:47 +01:00
|
|
|
if (class__nr_members(self) != class__nr_members(dup))
|
2007-01-04 04:41:11 +01:00
|
|
|
class__dupmsg(self, cu, dup, dup_cu,
|
|
|
|
&hdr, "nr_members: %u != %u\n",
|
2007-01-09 13:00:47 +01:00
|
|
|
class__nr_members(self), class__nr_members(dup));
|
2006-12-18 14:05:07 +01:00
|
|
|
|
|
|
|
if (self->nr_holes != dup->nr_holes)
|
2007-01-04 04:41:11 +01:00
|
|
|
class__dupmsg(self, cu, dup, dup_cu,
|
|
|
|
&hdr, "nr_holes: %u != %u\n",
|
2006-12-18 14:05:07 +01:00
|
|
|
self->nr_holes, dup->nr_holes);
|
|
|
|
|
|
|
|
if (self->nr_bit_holes != dup->nr_bit_holes)
|
2007-01-04 04:41:11 +01:00
|
|
|
class__dupmsg(self, cu, dup, dup_cu,
|
|
|
|
&hdr, "nr_bit_holes: %u != %u\n",
|
2006-12-18 14:05:07 +01:00
|
|
|
self->nr_bit_holes, dup->nr_bit_holes);
|
|
|
|
|
|
|
|
if (self->padding != dup->padding)
|
2007-01-04 04:41:11 +01:00
|
|
|
class__dupmsg(self, cu, dup, dup_cu,
|
|
|
|
&hdr, "padding: %u != %u\n",
|
2006-12-18 14:05:07 +01:00
|
|
|
self->padding, dup->padding);
|
|
|
|
|
2006-12-18 13:47:39 +01:00
|
|
|
/* XXX put more checks here: member types, member ordering, etc */
|
|
|
|
|
|
|
|
if (hdr)
|
|
|
|
putchar('\n');
|
|
|
|
}
|
|
|
|
|
2007-01-29 13:42:03 +01:00
|
|
|
static struct tag *tag__filter(struct tag *tag, struct cu *cu,
|
|
|
|
void *cookie __unused)
|
2006-12-01 02:12:21 +01:00
|
|
|
{
|
2006-12-18 13:47:39 +01:00
|
|
|
struct structure *str;
|
2006-12-29 18:28:58 +01:00
|
|
|
struct class *class;
|
2007-01-07 15:30:58 +01:00
|
|
|
const char *name;
|
2006-12-18 13:47:39 +01:00
|
|
|
|
2007-01-28 14:07:22 +01:00
|
|
|
if (tag->tag != DW_TAG_structure_type)
|
2006-12-01 02:12:21 +01:00
|
|
|
return NULL;
|
|
|
|
|
2006-12-29 18:28:58 +01:00
|
|
|
class = tag__class(tag);
|
2007-01-07 15:30:58 +01:00
|
|
|
name = class__name(class);
|
2006-12-01 03:00:24 +01:00
|
|
|
|
2007-01-09 13:00:47 +01:00
|
|
|
if (class__is_declaration(class))
|
2006-12-18 13:47:39 +01:00
|
|
|
return NULL;
|
|
|
|
|
2007-01-28 14:07:22 +01:00
|
|
|
if (!class__include_anonymous && name == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (class__exclude_prefix != NULL && name &&
|
2007-01-07 15:30:58 +01:00
|
|
|
strncmp(class__exclude_prefix, name,
|
2006-12-01 03:00:24 +01:00
|
|
|
class__exclude_prefix_len) == 0)
|
2006-12-01 02:12:21 +01:00
|
|
|
return NULL;
|
|
|
|
|
2006-12-01 03:08:10 +01:00
|
|
|
if (decl_exclude_prefix != NULL &&
|
2007-01-07 15:30:58 +01:00
|
|
|
(tag->decl_file == NULL ||
|
|
|
|
strncmp(decl_exclude_prefix, tag->decl_file,
|
2006-12-01 03:08:10 +01:00
|
|
|
decl_exclude_prefix_len) == 0))
|
|
|
|
return NULL;
|
|
|
|
|
2007-01-04 04:41:11 +01:00
|
|
|
class__find_holes(class, cu);
|
2006-12-07 19:14:15 +01:00
|
|
|
|
2006-12-18 13:47:39 +01:00
|
|
|
if (class->nr_holes < nr_holes ||
|
|
|
|
class->nr_bit_holes < nr_bit_holes)
|
|
|
|
return NULL;
|
|
|
|
|
2007-01-07 15:30:58 +01:00
|
|
|
str = structures__find(name);
|
2006-12-18 13:47:39 +01:00
|
|
|
if (str != NULL) {
|
[PAHOLE]: Reorganize bitfields
This cset also does a fixup for cases where the compiler keeps the type
specified by the programmer for a bitfield but uses less space to combine with
the next, non-bitfield member, these cases can be caught using plain pahole and
will appear with this comment:
/* --- cacheline 1 boundary (64 bytes) --- */
int bitfield1:1; /* 64 4 */
int bitfield2:1; /* 64 4 */
/* XXX 14 bits hole, try to pack */
/* Bitfield WARNING: DWARF size=4, real size=2 */
short int d; /* 66 2 */
The fixup is done prior to reorganizing the fields.
Now an example of this code in action:
[acme@filo examples]$ cat swiss_cheese.c
<SNIP>
struct cheese {
char id;
short number;
char name[52];
int a:1;
int b;
int bitfield1:1;
int bitfield2:1;
short d;
short e;
short last:5;
};
<SNIP>
[acme@filo examples]$
Lets look at the layout:
[acme@filo examples]$ pahole swiss_cheese cheese
/* <11b> /home/acme/git/pahole/examples/swiss_cheese.c:3 */
struct cheese {
char id; /* 0 1 */
/* XXX 1 byte hole, try to pack */
short int number; /* 2 2 */
char name[52]; /* 4 52 */
int a:1; /* 56 4 */
/* XXX 31 bits hole, try to pack */
int b; /* 60 4 */
/* --- cacheline 1 boundary (64 bytes) --- */
int bitfield1:1; /* 64 4 */
int bitfield2:1; /* 64 4 */
/* XXX 14 bits hole, try to pack */
/* Bitfield WARNING: DWARF size=4, real size=2 */
short int d; /* 66 2 */
short int e; /* 68 2 */
short int last:5; /* 70 2 */
}; /* size: 72, cachelines: 2 */
/* sum members: 71, holes: 1, sum holes: 1 */
/* bit holes: 2, sum bit holes: 45 bits */
/* bit_padding: 11 bits */
/* last cacheline: 8 bytes */
[acme@filo examples]$
Full of holes, has bit padding and uses more than one 64 bytes cacheline.
Now lets ask pahole to reorganize it:
[acme@filo examples]$ pahole --reorganize --verbose swiss_cheese cheese
/* Demoting bitfield ('a' ... 'a') from 'int' to 'unsigned char' */
/* Demoting bitfield ('bitfield1' ... 'bitfield2') from 'short unsigned int' to 'unsigned char' */
/* Demoting bitfield ('last') from 'short int' to 'unsigned char' */
/* Moving 'bitfield2:1' from after 'bitfield1' to after 'a:1' */
/* Moving 'bitfield1:1' from after 'b' to after 'bitfield2:1' */
/* Moving 'last:5' from after 'e' to after 'bitfield1:1' */
/* Moving bitfield('a' ... 'last') from after 'name' to after 'id' */
/* Moving 'e' from after 'd' to after 'b' */
/* <11b> /home/acme/git/pahole/examples/swiss_cheese.c:3 */
struct cheese {
char id; /* 0 1 */
unsigned char a:1; /* 1 1 */
unsigned char bitfield2:1; /* 1 1 */
unsigned char bitfield1:1; /* 1 1 */
unsigned char last:5; /* 1 1 */
short int number; /* 2 2 */
char name[52]; /* 4 52 */
int b; /* 56 4 */
short int e; /* 60 2 */
short int d; /* 62 2 */
/* --- cacheline 1 boundary (64 bytes) --- */
}; /* size: 64, cachelines: 1 */
/* saved 8 bytes and 1 cacheline! */
[acme@filo examples]$
Instant karma, it gets completely packed, and look ma, no
__attribute__((packed)) :-)
With this struct task_struct in the linux kernel is shrunk by 12 bytes, there
is more 4 bytes to save with another technique that involves not combining
holes, but using the last single hole to fill it with members at the tail of
the struct.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
2007-02-01 13:51:16 +01:00
|
|
|
if (global_verbose)
|
2007-01-12 01:11:31 +01:00
|
|
|
class__chkdupdef(str->class, str->cu, class, cu);
|
2006-12-18 13:47:39 +01:00
|
|
|
str->nr_files++;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-04-01 14:31:35 +02:00
|
|
|
if (show_packable && !class__packable(class, cu))
|
2006-12-07 19:14:15 +01:00
|
|
|
return NULL;
|
|
|
|
|
2006-12-29 18:28:58 +01:00
|
|
|
return tag;
|
2006-12-01 02:12:21 +01:00
|
|
|
}
|
|
|
|
|
2007-01-29 13:42:03 +01:00
|
|
|
static int unique_iterator(struct tag *tag, struct cu *cu,
|
|
|
|
void *cookie __unused)
|
2006-11-04 00:24:37 +01:00
|
|
|
{
|
2007-01-04 04:41:11 +01:00
|
|
|
structures__add(tag__class(tag), cu);
|
2006-11-04 00:24:37 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-12-18 13:47:39 +01:00
|
|
|
static int cu_unique_iterator(struct cu *cu, void *cookie)
|
2006-11-04 00:24:37 +01:00
|
|
|
{
|
2006-12-29 18:28:58 +01:00
|
|
|
return cu__for_each_tag(cu, unique_iterator, cookie, tag__filter);
|
2006-11-04 00:24:37 +01:00
|
|
|
}
|
|
|
|
|
2007-01-29 13:42:03 +01:00
|
|
|
static struct tag *nr_methods__filter(struct tag *tag, struct cu *cu __unused,
|
|
|
|
void *cookie __unused)
|
2007-01-13 16:59:32 +01:00
|
|
|
{
|
|
|
|
if (tag->tag != DW_TAG_subprogram)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (function__declared_inline(tag__function(tag)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return tag;
|
|
|
|
}
|
|
|
|
|
2007-01-29 13:42:03 +01:00
|
|
|
static int nr_methods_iterator(struct tag *tag, struct cu *cu,
|
|
|
|
void *cookie __unused)
|
2007-01-13 16:59:32 +01:00
|
|
|
{
|
|
|
|
struct parameter *pos;
|
|
|
|
struct structure *str;
|
|
|
|
struct type *ctype;
|
|
|
|
|
|
|
|
list_for_each_entry(pos, &tag__ftype(tag)->parms, tag.node) {
|
|
|
|
struct tag *type =
|
|
|
|
cu__find_tag_by_id(cu, parameter__type(pos, cu));
|
|
|
|
|
|
|
|
if (type == NULL || type->tag != DW_TAG_pointer_type)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
type = cu__find_tag_by_id(cu, type->type);
|
|
|
|
if (type == NULL || type->tag != DW_TAG_structure_type)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ctype = tag__type(type);
|
|
|
|
if (ctype->name == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
str = structures__find(ctype->name);
|
|
|
|
if (str != NULL)
|
|
|
|
++str->nr_methods;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int cu_nr_methods_iterator(struct cu *cu, void *cookie)
|
|
|
|
{
|
|
|
|
return cu__for_each_tag(cu, nr_methods_iterator, cookie,
|
|
|
|
nr_methods__filter);
|
|
|
|
}
|
|
|
|
|
2007-03-30 15:07:01 +02:00
|
|
|
static const struct argp_option pahole__options[] = {
|
|
|
|
{
|
|
|
|
.name = "bit_holes",
|
|
|
|
.key = 'B',
|
|
|
|
.arg = "NR_HOLES",
|
|
|
|
.doc = "Show only structs at least NR_HOLES bit holes"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "cacheline_size",
|
|
|
|
.key = 'c',
|
|
|
|
.arg = "SIZE",
|
|
|
|
.doc = "set cacheline size to SIZE"
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "holes",
|
|
|
|
.key = 'H',
|
|
|
|
.arg = "NR_HOLES",
|
|
|
|
.doc = "show only structs at least NR_HOLES holes",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "packable",
|
[PAHOLE]: Use cus__loadfl, i.e. libdwfl
Now we have:
[acme@filo pahole]$ pahole --help
Usage: pahole [OPTION...] [FILE] {[CLASS]}
-a, --anon_include include anonymous classes
-A, --nested_anon_include include nested (inside other structs) anonymous
classes
-B, --bit_holes=NR_HOLES Show only structs at least NR_HOLES bit holes
-c, --cacheline_size=SIZE set cacheline size to SIZE
-D, --decl_exclude=PREFIX exclude classes declared in files with PREFIX
-E, --expand_types expand class members
-H, --holes=NR_HOLES show only structs at least NR_HOLES holes
-m, --nr_methods show number of methods
-n, --nr_members show number of members
-N, --class_name_len show size of classes
-P, --packable show only structs that has holes that can be
packed
-R, --reorganize reorg struct trying to kill holes
-s, --sizes show size of classes
-S, --show_reorg_steps show the struct layout at each reorganization step
-t, --nr_definitions show how many times struct was defined
-V, --verbose be verbose
-x, --exclude=PREFIX exclude PREFIXed classes
-X, --cu_exclude=PREFIX exclude PREFIXed compilation units
Input Selection:
--debuginfo-path=PATH Search path for separate debuginfo files
-e, --executable=FILE Find addresses in FILE
-k, --kernel Find addresses in the running kernel
-K, --offline-kernel[=RELEASE] Kernel with all modules
-M, --linux-process-map=FILE Find addresses in files mapped as read from
FILE in Linux /proc/PID/maps format
-p, --pid=PID Find addresses in files mapped into process PID
-?, --help Give this help list
--usage Give a short usage message
Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
2007-03-30 18:25:51 +02:00
|
|
|
.key = 'P',
|
2007-03-30 15:07:01 +02:00
|
|
|
.doc = "show only structs that has holes that can be packed",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "expand_types",
|
[PAHOLE]: Use cus__loadfl, i.e. libdwfl
Now we have:
[acme@filo pahole]$ pahole --help
Usage: pahole [OPTION...] [FILE] {[CLASS]}
-a, --anon_include include anonymous classes
-A, --nested_anon_include include nested (inside other structs) anonymous
classes
-B, --bit_holes=NR_HOLES Show only structs at least NR_HOLES bit holes
-c, --cacheline_size=SIZE set cacheline size to SIZE
-D, --decl_exclude=PREFIX exclude classes declared in files with PREFIX
-E, --expand_types expand class members
-H, --holes=NR_HOLES show only structs at least NR_HOLES holes
-m, --nr_methods show number of methods
-n, --nr_members show number of members
-N, --class_name_len show size of classes
-P, --packable show only structs that has holes that can be
packed
-R, --reorganize reorg struct trying to kill holes
-s, --sizes show size of classes
-S, --show_reorg_steps show the struct layout at each reorganization step
-t, --nr_definitions show how many times struct was defined
-V, --verbose be verbose
-x, --exclude=PREFIX exclude PREFIXed classes
-X, --cu_exclude=PREFIX exclude PREFIXed compilation units
Input Selection:
--debuginfo-path=PATH Search path for separate debuginfo files
-e, --executable=FILE Find addresses in FILE
-k, --kernel Find addresses in the running kernel
-K, --offline-kernel[=RELEASE] Kernel with all modules
-M, --linux-process-map=FILE Find addresses in files mapped as read from
FILE in Linux /proc/PID/maps format
-p, --pid=PID Find addresses in files mapped into process PID
-?, --help Give this help list
--usage Give a short usage message
Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
2007-03-30 18:25:51 +02:00
|
|
|
.key = 'E',
|
2007-03-30 15:07:01 +02:00
|
|
|
.doc = "expand class members",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "nr_members",
|
|
|
|
.key = 'n',
|
|
|
|
.doc = "show number of members",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "reorganize",
|
[PAHOLE]: Use cus__loadfl, i.e. libdwfl
Now we have:
[acme@filo pahole]$ pahole --help
Usage: pahole [OPTION...] [FILE] {[CLASS]}
-a, --anon_include include anonymous classes
-A, --nested_anon_include include nested (inside other structs) anonymous
classes
-B, --bit_holes=NR_HOLES Show only structs at least NR_HOLES bit holes
-c, --cacheline_size=SIZE set cacheline size to SIZE
-D, --decl_exclude=PREFIX exclude classes declared in files with PREFIX
-E, --expand_types expand class members
-H, --holes=NR_HOLES show only structs at least NR_HOLES holes
-m, --nr_methods show number of methods
-n, --nr_members show number of members
-N, --class_name_len show size of classes
-P, --packable show only structs that has holes that can be
packed
-R, --reorganize reorg struct trying to kill holes
-s, --sizes show size of classes
-S, --show_reorg_steps show the struct layout at each reorganization step
-t, --nr_definitions show how many times struct was defined
-V, --verbose be verbose
-x, --exclude=PREFIX exclude PREFIXed classes
-X, --cu_exclude=PREFIX exclude PREFIXed compilation units
Input Selection:
--debuginfo-path=PATH Search path for separate debuginfo files
-e, --executable=FILE Find addresses in FILE
-k, --kernel Find addresses in the running kernel
-K, --offline-kernel[=RELEASE] Kernel with all modules
-M, --linux-process-map=FILE Find addresses in files mapped as read from
FILE in Linux /proc/PID/maps format
-p, --pid=PID Find addresses in files mapped into process PID
-?, --help Give this help list
--usage Give a short usage message
Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
2007-03-30 18:25:51 +02:00
|
|
|
.key = 'R',
|
2007-03-30 15:07:01 +02:00
|
|
|
.doc = "reorg struct trying to kill holes",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "show_reorg_steps",
|
|
|
|
.key = 'S',
|
|
|
|
.doc = "show the struct layout at each reorganization step",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "class_name_len",
|
|
|
|
.key = 'N',
|
|
|
|
.doc = "show size of classes",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "nr_methods",
|
|
|
|
.key = 'm',
|
|
|
|
.doc = "show number of methods",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "sizes",
|
|
|
|
.key = 's',
|
|
|
|
.doc = "show size of classes",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "nr_definitions",
|
|
|
|
.key = 't',
|
|
|
|
.doc = "show how many times struct was defined",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "decl_exclude",
|
|
|
|
.key = 'D',
|
|
|
|
.arg = "PREFIX",
|
|
|
|
.doc = "exclude classes declared in files with PREFIX",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "exclude",
|
|
|
|
.key = 'x',
|
|
|
|
.arg = "PREFIX",
|
|
|
|
.doc = "exclude PREFIXed classes",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "cu_exclude",
|
|
|
|
.key = 'X',
|
|
|
|
.arg = "PREFIX",
|
|
|
|
.doc = "exclude PREFIXed compilation units",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "anon_include",
|
|
|
|
.key = 'a',
|
|
|
|
.doc = "include anonymous classes",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "nested_anon_include",
|
|
|
|
.key = 'A',
|
|
|
|
.doc = "include nested (inside other structs) anonymous classes",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = "verbose",
|
|
|
|
.key = 'V',
|
|
|
|
.doc = "be verbose",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.name = NULL,
|
|
|
|
}
|
2006-11-02 17:47:37 +01:00
|
|
|
};
|
|
|
|
|
2007-03-30 15:07:01 +02:00
|
|
|
static void (*formatter)(const struct structure *s) = class_formatter;
|
|
|
|
|
|
|
|
static error_t pahole__options_parser(int key, char *arg,
|
[PAHOLE]: Use cus__loadfl, i.e. libdwfl
Now we have:
[acme@filo pahole]$ pahole --help
Usage: pahole [OPTION...] [FILE] {[CLASS]}
-a, --anon_include include anonymous classes
-A, --nested_anon_include include nested (inside other structs) anonymous
classes
-B, --bit_holes=NR_HOLES Show only structs at least NR_HOLES bit holes
-c, --cacheline_size=SIZE set cacheline size to SIZE
-D, --decl_exclude=PREFIX exclude classes declared in files with PREFIX
-E, --expand_types expand class members
-H, --holes=NR_HOLES show only structs at least NR_HOLES holes
-m, --nr_methods show number of methods
-n, --nr_members show number of members
-N, --class_name_len show size of classes
-P, --packable show only structs that has holes that can be
packed
-R, --reorganize reorg struct trying to kill holes
-s, --sizes show size of classes
-S, --show_reorg_steps show the struct layout at each reorganization step
-t, --nr_definitions show how many times struct was defined
-V, --verbose be verbose
-x, --exclude=PREFIX exclude PREFIXed classes
-X, --cu_exclude=PREFIX exclude PREFIXed compilation units
Input Selection:
--debuginfo-path=PATH Search path for separate debuginfo files
-e, --executable=FILE Find addresses in FILE
-k, --kernel Find addresses in the running kernel
-K, --offline-kernel[=RELEASE] Kernel with all modules
-M, --linux-process-map=FILE Find addresses in files mapped as read from
FILE in Linux /proc/PID/maps format
-p, --pid=PID Find addresses in files mapped into process PID
-?, --help Give this help list
--usage Give a short usage message
Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
2007-03-30 18:25:51 +02:00
|
|
|
struct argp_state *state)
|
2006-11-02 17:47:37 +01:00
|
|
|
{
|
2007-03-30 15:07:01 +02:00
|
|
|
switch (key) {
|
[PAHOLE]: Use cus__loadfl, i.e. libdwfl
Now we have:
[acme@filo pahole]$ pahole --help
Usage: pahole [OPTION...] [FILE] {[CLASS]}
-a, --anon_include include anonymous classes
-A, --nested_anon_include include nested (inside other structs) anonymous
classes
-B, --bit_holes=NR_HOLES Show only structs at least NR_HOLES bit holes
-c, --cacheline_size=SIZE set cacheline size to SIZE
-D, --decl_exclude=PREFIX exclude classes declared in files with PREFIX
-E, --expand_types expand class members
-H, --holes=NR_HOLES show only structs at least NR_HOLES holes
-m, --nr_methods show number of methods
-n, --nr_members show number of members
-N, --class_name_len show size of classes
-P, --packable show only structs that has holes that can be
packed
-R, --reorganize reorg struct trying to kill holes
-s, --sizes show size of classes
-S, --show_reorg_steps show the struct layout at each reorganization step
-t, --nr_definitions show how many times struct was defined
-V, --verbose be verbose
-x, --exclude=PREFIX exclude PREFIXed classes
-X, --cu_exclude=PREFIX exclude PREFIXed compilation units
Input Selection:
--debuginfo-path=PATH Search path for separate debuginfo files
-e, --executable=FILE Find addresses in FILE
-k, --kernel Find addresses in the running kernel
-K, --offline-kernel[=RELEASE] Kernel with all modules
-M, --linux-process-map=FILE Find addresses in files mapped as read from
FILE in Linux /proc/PID/maps format
-p, --pid=PID Find addresses in files mapped into process PID
-?, --help Give this help list
--usage Give a short usage message
Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
2007-03-30 18:25:51 +02:00
|
|
|
case ARGP_KEY_INIT: state->child_inputs[0] = state->input; break;
|
2007-03-30 15:07:01 +02:00
|
|
|
case 'c': cacheline_size = atoi(arg); break;
|
|
|
|
case 'H': nr_holes = atoi(arg); break;
|
|
|
|
case 'B': nr_bit_holes = atoi(arg); break;
|
[PAHOLE]: Use cus__loadfl, i.e. libdwfl
Now we have:
[acme@filo pahole]$ pahole --help
Usage: pahole [OPTION...] [FILE] {[CLASS]}
-a, --anon_include include anonymous classes
-A, --nested_anon_include include nested (inside other structs) anonymous
classes
-B, --bit_holes=NR_HOLES Show only structs at least NR_HOLES bit holes
-c, --cacheline_size=SIZE set cacheline size to SIZE
-D, --decl_exclude=PREFIX exclude classes declared in files with PREFIX
-E, --expand_types expand class members
-H, --holes=NR_HOLES show only structs at least NR_HOLES holes
-m, --nr_methods show number of methods
-n, --nr_members show number of members
-N, --class_name_len show size of classes
-P, --packable show only structs that has holes that can be
packed
-R, --reorganize reorg struct trying to kill holes
-s, --sizes show size of classes
-S, --show_reorg_steps show the struct layout at each reorganization step
-t, --nr_definitions show how many times struct was defined
-V, --verbose be verbose
-x, --exclude=PREFIX exclude PREFIXed classes
-X, --cu_exclude=PREFIX exclude PREFIXed compilation units
Input Selection:
--debuginfo-path=PATH Search path for separate debuginfo files
-e, --executable=FILE Find addresses in FILE
-k, --kernel Find addresses in the running kernel
-K, --offline-kernel[=RELEASE] Kernel with all modules
-M, --linux-process-map=FILE Find addresses in files mapped as read from
FILE in Linux /proc/PID/maps format
-p, --pid=PID Find addresses in files mapped into process PID
-?, --help Give this help list
--usage Give a short usage message
Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
2007-03-30 18:25:51 +02:00
|
|
|
case 'E': expand_types = 1; break;
|
|
|
|
case 'R': reorganize = 1; break;
|
2007-03-30 15:07:01 +02:00
|
|
|
case 'S': show_reorg_steps = 1; break;
|
|
|
|
case 's': formatter = size_formatter; break;
|
|
|
|
case 'n': formatter = nr_members_formatter; break;
|
|
|
|
case 'N': formatter = class_name_len_formatter; break;
|
|
|
|
case 'm': formatter = nr_methods_formatter; break;
|
[PAHOLE]: Use cus__loadfl, i.e. libdwfl
Now we have:
[acme@filo pahole]$ pahole --help
Usage: pahole [OPTION...] [FILE] {[CLASS]}
-a, --anon_include include anonymous classes
-A, --nested_anon_include include nested (inside other structs) anonymous
classes
-B, --bit_holes=NR_HOLES Show only structs at least NR_HOLES bit holes
-c, --cacheline_size=SIZE set cacheline size to SIZE
-D, --decl_exclude=PREFIX exclude classes declared in files with PREFIX
-E, --expand_types expand class members
-H, --holes=NR_HOLES show only structs at least NR_HOLES holes
-m, --nr_methods show number of methods
-n, --nr_members show number of members
-N, --class_name_len show size of classes
-P, --packable show only structs that has holes that can be
packed
-R, --reorganize reorg struct trying to kill holes
-s, --sizes show size of classes
-S, --show_reorg_steps show the struct layout at each reorganization step
-t, --nr_definitions show how many times struct was defined
-V, --verbose be verbose
-x, --exclude=PREFIX exclude PREFIXed classes
-X, --cu_exclude=PREFIX exclude PREFIXed compilation units
Input Selection:
--debuginfo-path=PATH Search path for separate debuginfo files
-e, --executable=FILE Find addresses in FILE
-k, --kernel Find addresses in the running kernel
-K, --offline-kernel[=RELEASE] Kernel with all modules
-M, --linux-process-map=FILE Find addresses in files mapped as read from
FILE in Linux /proc/PID/maps format
-p, --pid=PID Find addresses in files mapped into process PID
-?, --help Give this help list
--usage Give a short usage message
Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
2007-03-30 18:25:51 +02:00
|
|
|
case 'P': show_packable = 1; break;
|
2007-03-30 15:07:01 +02:00
|
|
|
case 't': formatter = nr_definitions_formatter; break;
|
|
|
|
case 'a': class__include_anonymous = 1; break;
|
|
|
|
case 'A': class__include_nested_anonymous = 1; break;
|
|
|
|
case 'D': decl_exclude_prefix = arg;
|
|
|
|
decl_exclude_prefix_len = strlen(decl_exclude_prefix);
|
|
|
|
break;
|
|
|
|
case 'x': class__exclude_prefix = arg;
|
|
|
|
class__exclude_prefix_len = strlen(class__exclude_prefix);
|
|
|
|
break;
|
|
|
|
case 'X': cu__exclude_prefix = arg;
|
|
|
|
cu__exclude_prefix_len = strlen(cu__exclude_prefix);
|
|
|
|
break;
|
|
|
|
case 'V': global_verbose = 1; break;
|
|
|
|
default:
|
|
|
|
return ARGP_ERR_UNKNOWN;
|
|
|
|
}
|
|
|
|
return 0;
|
2006-11-02 17:47:37 +01:00
|
|
|
}
|
|
|
|
|
2007-03-30 15:07:01 +02:00
|
|
|
static const char pahole__args_doc[] = "[FILE] {[CLASS]}";
|
|
|
|
|
|
|
|
static struct argp pahole__argp = {
|
|
|
|
.options = pahole__options,
|
|
|
|
.parser = pahole__options_parser,
|
|
|
|
.args_doc = pahole__args_doc,
|
|
|
|
};
|
|
|
|
|
2006-10-28 19:08:46 +02:00
|
|
|
int main(int argc, char *argv[])
|
|
|
|
{
|
2007-03-30 15:07:01 +02:00
|
|
|
int err;
|
2006-11-11 19:31:04 +01:00
|
|
|
struct cus *cus;
|
2006-11-02 17:47:37 +01:00
|
|
|
char *class_name = NULL;
|
2007-03-30 15:07:01 +02:00
|
|
|
int remaining;
|
2006-11-02 17:47:37 +01:00
|
|
|
|
2007-01-07 15:30:58 +01:00
|
|
|
cus = cus__new(NULL, NULL);
|
2006-11-11 19:31:04 +01:00
|
|
|
if (cus == NULL) {
|
|
|
|
fputs("pahole: insufficient memory\n", stderr);
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
[PAHOLE]: Use cus__loadfl, i.e. libdwfl
Now we have:
[acme@filo pahole]$ pahole --help
Usage: pahole [OPTION...] [FILE] {[CLASS]}
-a, --anon_include include anonymous classes
-A, --nested_anon_include include nested (inside other structs) anonymous
classes
-B, --bit_holes=NR_HOLES Show only structs at least NR_HOLES bit holes
-c, --cacheline_size=SIZE set cacheline size to SIZE
-D, --decl_exclude=PREFIX exclude classes declared in files with PREFIX
-E, --expand_types expand class members
-H, --holes=NR_HOLES show only structs at least NR_HOLES holes
-m, --nr_methods show number of methods
-n, --nr_members show number of members
-N, --class_name_len show size of classes
-P, --packable show only structs that has holes that can be
packed
-R, --reorganize reorg struct trying to kill holes
-s, --sizes show size of classes
-S, --show_reorg_steps show the struct layout at each reorganization step
-t, --nr_definitions show how many times struct was defined
-V, --verbose be verbose
-x, --exclude=PREFIX exclude PREFIXed classes
-X, --cu_exclude=PREFIX exclude PREFIXed compilation units
Input Selection:
--debuginfo-path=PATH Search path for separate debuginfo files
-e, --executable=FILE Find addresses in FILE
-k, --kernel Find addresses in the running kernel
-K, --offline-kernel[=RELEASE] Kernel with all modules
-M, --linux-process-map=FILE Find addresses in files mapped as read from
FILE in Linux /proc/PID/maps format
-p, --pid=PID Find addresses in files mapped into process PID
-?, --help Give this help list
--usage Give a short usage message
Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
2007-03-30 18:25:51 +02:00
|
|
|
err = cus__loadfl(cus, &pahole__argp, argc, argv, &remaining);
|
|
|
|
if (err != 0)
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
|
|
|
|
switch (argc - remaining) {
|
|
|
|
case 0: break;
|
|
|
|
case 1: class_name = argv[remaining++]; break;
|
|
|
|
default:
|
|
|
|
argp_help(&pahole__argp, stderr, ARGP_HELP_SEE, "pahole");
|
2006-10-28 19:08:46 +02:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
2006-10-26 08:06:32 +02:00
|
|
|
|
[PAHOLE]: Use cus__loadfl, i.e. libdwfl
Now we have:
[acme@filo pahole]$ pahole --help
Usage: pahole [OPTION...] [FILE] {[CLASS]}
-a, --anon_include include anonymous classes
-A, --nested_anon_include include nested (inside other structs) anonymous
classes
-B, --bit_holes=NR_HOLES Show only structs at least NR_HOLES bit holes
-c, --cacheline_size=SIZE set cacheline size to SIZE
-D, --decl_exclude=PREFIX exclude classes declared in files with PREFIX
-E, --expand_types expand class members
-H, --holes=NR_HOLES show only structs at least NR_HOLES holes
-m, --nr_methods show number of methods
-n, --nr_members show number of members
-N, --class_name_len show size of classes
-P, --packable show only structs that has holes that can be
packed
-R, --reorganize reorg struct trying to kill holes
-s, --sizes show size of classes
-S, --show_reorg_steps show the struct layout at each reorganization step
-t, --nr_definitions show how many times struct was defined
-V, --verbose be verbose
-x, --exclude=PREFIX exclude PREFIXed classes
-X, --cu_exclude=PREFIX exclude PREFIXed compilation units
Input Selection:
--debuginfo-path=PATH Search path for separate debuginfo files
-e, --executable=FILE Find addresses in FILE
-k, --kernel Find addresses in the running kernel
-K, --offline-kernel[=RELEASE] Kernel with all modules
-M, --linux-process-map=FILE Find addresses in files mapped as read from
FILE in Linux /proc/PID/maps format
-p, --pid=PID Find addresses in files mapped into process PID
-?, --help Give this help list
--usage Give a short usage message
Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.
Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
2007-03-30 18:25:51 +02:00
|
|
|
dwarves__init(cacheline_size);
|
|
|
|
|
2006-12-18 13:47:39 +01:00
|
|
|
cus__for_each_cu(cus, cu_unique_iterator, NULL, cu__filter);
|
2007-01-13 16:59:32 +01:00
|
|
|
if (formatter == nr_methods_formatter)
|
|
|
|
cus__for_each_cu(cus, cu_nr_methods_iterator, NULL, cu__filter);
|
2006-12-18 13:47:39 +01:00
|
|
|
|
|
|
|
if (class_name != NULL) {
|
|
|
|
struct structure *s = structures__find(class_name);
|
|
|
|
|
|
|
|
if (s == NULL) {
|
2007-03-30 15:07:01 +02:00
|
|
|
fprintf(stderr, "struct %s not found!\n", class_name);
|
2006-12-18 13:47:39 +01:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
2007-01-30 16:32:55 +01:00
|
|
|
if (reorganize) {
|
|
|
|
size_t savings;
|
2007-02-01 15:27:43 +01:00
|
|
|
const uint8_t reorg_verbose =
|
|
|
|
show_reorg_steps ? 2 : global_verbose;
|
2007-02-01 17:09:48 +01:00
|
|
|
struct class *clone = class__clone(s->class, NULL);
|
2007-01-30 16:32:55 +01:00
|
|
|
if (clone == NULL) {
|
2007-03-30 15:07:01 +02:00
|
|
|
fprintf(stderr, "pahole: out of memory!\n");
|
2007-01-30 16:32:55 +01:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
2007-02-01 16:50:28 +01:00
|
|
|
class__reorganize(clone, s->cu, reorg_verbose, stdout);
|
2007-01-30 16:32:55 +01:00
|
|
|
savings = class__size(s->class) - class__size(clone);
|
2007-02-01 15:27:43 +01:00
|
|
|
if (savings != 0 && reorg_verbose) {
|
2007-01-30 16:32:55 +01:00
|
|
|
putchar('\n');
|
2007-02-01 15:27:43 +01:00
|
|
|
if (show_reorg_steps)
|
|
|
|
puts("/* Final reorganized struct: */");
|
|
|
|
}
|
2007-02-15 14:40:51 +01:00
|
|
|
tag__fprintf(class__tag(clone), s->cu, NULL, NULL, 0,
|
|
|
|
stdout);
|
2007-01-30 16:32:55 +01:00
|
|
|
if (savings != 0) {
|
|
|
|
const size_t cacheline_savings =
|
|
|
|
(tag__nr_cachelines(class__tag(s->class),
|
|
|
|
s->cu) -
|
|
|
|
tag__nr_cachelines(class__tag(clone),
|
|
|
|
s->cu));
|
|
|
|
|
2007-03-28 16:38:32 +02:00
|
|
|
printf(" /* saved %zd byte%s", savings,
|
2007-01-30 16:32:55 +01:00
|
|
|
savings != 1 ? "s" : "");
|
|
|
|
if (cacheline_savings != 0)
|
|
|
|
printf(" and %zu cacheline%s",
|
|
|
|
cacheline_savings,
|
|
|
|
cacheline_savings != 1 ?
|
|
|
|
"s" : "");
|
|
|
|
puts("! */");
|
|
|
|
}
|
|
|
|
} else
|
2007-02-15 14:40:51 +01:00
|
|
|
tag__fprintf(class__tag(s->class), s->cu, NULL, NULL,
|
|
|
|
expand_types, stdout);
|
2006-12-18 19:27:14 +01:00
|
|
|
} else
|
2006-12-18 13:47:39 +01:00
|
|
|
print_classes(formatter);
|
2006-10-25 18:32:07 +02:00
|
|
|
|
2006-10-28 19:08:46 +02:00
|
|
|
return EXIT_SUCCESS;
|
2006-10-25 01:42:39 +02:00
|
|
|
}
|