354 lines
9.2 KiB
C
354 lines
9.2 KiB
C
/*
|
|
Copyright (C) 2006 Mandriva Conectiva S.A.
|
|
Copyright (C) 2006 Arnaldo Carvalho de Melo <acme@mandriva.com>
|
|
|
|
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.
|
|
*/
|
|
|
|
#include <getopt.h>
|
|
#include <stdio.h>
|
|
#include <dwarf.h>
|
|
#include <stdarg.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "classes.h"
|
|
|
|
static char *class__exclude_prefix;
|
|
static size_t class__exclude_prefix_len;
|
|
|
|
static char *cu__exclude_prefix;
|
|
static size_t cu__exclude_prefix_len;
|
|
|
|
static char *decl_exclude_prefix;
|
|
static size_t decl_exclude_prefix_len;
|
|
|
|
static uint16_t nr_holes;
|
|
static uint16_t nr_bit_holes;
|
|
static uint8_t show_packable;
|
|
|
|
struct structure {
|
|
struct list_head node;
|
|
const struct class *class;
|
|
uint32_t nr_files;
|
|
};
|
|
|
|
static struct structure *structure__new(const struct class *class)
|
|
{
|
|
struct structure *self = malloc(sizeof(*self));
|
|
|
|
if (self != NULL) {
|
|
self->class = class;
|
|
self->nr_files = 1;
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
static LIST_HEAD(structures__list);
|
|
|
|
static struct structure *structures__find(const char *name)
|
|
{
|
|
struct structure *pos;
|
|
|
|
list_for_each_entry(pos, &structures__list, node)
|
|
if (strcmp(pos->class->name, name) == 0)
|
|
return pos;
|
|
return NULL;
|
|
}
|
|
|
|
static void structures__add(const struct class *class)
|
|
{
|
|
struct structure *str = structure__new(class);
|
|
|
|
if (str != NULL)
|
|
list_add(&str->node, &structures__list);
|
|
}
|
|
|
|
static void nr_definitions_formatter(const struct structure *self)
|
|
{
|
|
printf("%s: %u\n", self->class->name, self->nr_files);
|
|
}
|
|
|
|
static void nr_members_formatter(const struct structure *self)
|
|
{
|
|
printf("%s: %u\n", self->class->name, self->class->nr_members);
|
|
}
|
|
|
|
static void size_formatter(const struct structure *self)
|
|
{
|
|
printf("%s: %u %u\n", self->class->name, self->class->size,
|
|
self->class->nr_holes);
|
|
}
|
|
|
|
static void class_name_len_formatter(const struct structure *self)
|
|
{
|
|
printf("%s: %u\n", self->class->name, strlen(self->class->name));
|
|
}
|
|
|
|
static void class_formatter(const struct structure *self)
|
|
{
|
|
tag__print(&self->class->tag, self->class->cu, NULL, NULL);
|
|
printf(" /* definitions: %u */\n", self->nr_files);
|
|
putchar('\n');
|
|
}
|
|
|
|
static void print_classes(void (*formatter)(const struct structure *s))
|
|
{
|
|
struct structure *pos;
|
|
|
|
list_for_each_entry(pos, &structures__list, node)
|
|
formatter(pos);
|
|
}
|
|
|
|
static struct cu *cu__filter(struct cu *cu)
|
|
{
|
|
if (cu__exclude_prefix != NULL &&
|
|
(cu->name == NULL ||
|
|
strncmp(cu__exclude_prefix, cu->name,
|
|
cu__exclude_prefix_len) == 0))
|
|
return NULL;
|
|
|
|
return cu;
|
|
}
|
|
|
|
static int class__packable(const struct class *self)
|
|
{
|
|
struct class_member *pos;
|
|
|
|
if (self->nr_holes == 0 && self->nr_bit_holes == 0)
|
|
return 0;
|
|
|
|
list_for_each_entry(pos, &self->members, tag.node)
|
|
if (pos->hole != 0 &&
|
|
class__find_bit_hole(self, pos, pos->hole * 8) != NULL)
|
|
return 1;
|
|
else if (pos->bit_hole != 0 &&
|
|
class__find_bit_hole(self, pos, pos->bit_hole) != NULL)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void class__dupmsg(const struct class *self, const struct class *dup,
|
|
char *hdr, const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
|
|
if (!*hdr)
|
|
printf("class: %s\nfirst: %s\ncurrent: %s\n",
|
|
self->name, self->cu->name, dup->cu->name);
|
|
|
|
va_start(args, fmt);
|
|
vprintf(fmt, args);
|
|
va_end(args);
|
|
*hdr = 1;
|
|
}
|
|
|
|
static void class__chkdupdef(const struct class *self, struct class *dup)
|
|
{
|
|
char hdr = 0;
|
|
|
|
if (self->size != dup->size)
|
|
class__dupmsg(self, dup, &hdr, "size: %u != %u\n",
|
|
self->size, dup->size);
|
|
|
|
if (self->nr_members != dup->nr_members)
|
|
class__dupmsg(self, dup, &hdr, "nr_members: %u != %u\n",
|
|
self->nr_members, dup->nr_members);
|
|
|
|
if (self->nr_holes != dup->nr_holes)
|
|
class__dupmsg(self, dup, &hdr, "nr_holes: %u != %u\n",
|
|
self->nr_holes, dup->nr_holes);
|
|
|
|
if (self->nr_bit_holes != dup->nr_bit_holes)
|
|
class__dupmsg(self, dup, &hdr, "nr_bit_holes: %u != %u\n",
|
|
self->nr_bit_holes, dup->nr_bit_holes);
|
|
|
|
if (self->padding != dup->padding)
|
|
class__dupmsg(self, dup, &hdr, "padding: %u != %u\n",
|
|
self->padding, dup->padding);
|
|
|
|
/* XXX put more checks here: member types, member ordering, etc */
|
|
|
|
if (hdr)
|
|
putchar('\n');
|
|
}
|
|
|
|
static struct tag *tag__to_struct(struct tag *tag, const struct cu *cu)
|
|
{
|
|
struct tag *typedef_alias;
|
|
|
|
if (!tag__is_struct(tag, &typedef_alias, cu))
|
|
return NULL;
|
|
return typedef_alias ?: tag;
|
|
}
|
|
|
|
static struct tag *tag__filter(struct tag *tag, struct cu *cu)
|
|
{
|
|
struct structure *str;
|
|
struct class *class;
|
|
|
|
tag = tag__to_struct(tag, cu);
|
|
if (tag == NULL) /* Not a structure */
|
|
return NULL;
|
|
|
|
class = tag__class(tag);
|
|
|
|
if (class->name == NULL)
|
|
return NULL;
|
|
|
|
if (class->declaration)
|
|
return NULL;
|
|
|
|
if (class__exclude_prefix != NULL &&
|
|
strncmp(class__exclude_prefix, class->name,
|
|
class__exclude_prefix_len) == 0)
|
|
return NULL;
|
|
|
|
if (decl_exclude_prefix != NULL &&
|
|
(class->tag.decl_file == NULL ||
|
|
strncmp(decl_exclude_prefix, class->tag.decl_file,
|
|
decl_exclude_prefix_len) == 0))
|
|
return NULL;
|
|
|
|
class__find_holes(class);
|
|
|
|
if (class->nr_holes < nr_holes ||
|
|
class->nr_bit_holes < nr_bit_holes)
|
|
return NULL;
|
|
|
|
str = structures__find(class->name);
|
|
if (str != NULL) {
|
|
class__chkdupdef(str->class, class);
|
|
str->nr_files++;
|
|
return NULL;
|
|
}
|
|
|
|
if (show_packable && !class__packable(class))
|
|
return NULL;
|
|
|
|
return tag;
|
|
}
|
|
|
|
static int unique_iterator(struct tag *tag, struct cu *cu, void *cookie)
|
|
{
|
|
structures__add(tag__class(tag));
|
|
return 0;
|
|
}
|
|
|
|
static int cu_unique_iterator(struct cu *cu, void *cookie)
|
|
{
|
|
return cu__for_each_tag(cu, unique_iterator, cookie, tag__filter);
|
|
}
|
|
|
|
static struct option long_options[] = {
|
|
{ "cacheline_size", required_argument, NULL, 'c' },
|
|
{ "class_name_len", no_argument, NULL, 'N' },
|
|
{ "help", no_argument, NULL, 'h' },
|
|
{ "bit_holes", required_argument, NULL, 'B' },
|
|
{ "holes", required_argument, NULL, 'H' },
|
|
{ "nr_members", no_argument, NULL, 'n' },
|
|
{ "sizes", no_argument, NULL, 's' },
|
|
{ "nr_definitions", no_argument, NULL, 't' },
|
|
{ "exclude", required_argument, NULL, 'x' },
|
|
{ "cu_exclude", required_argument, NULL, 'X' },
|
|
{ "decl_exclude", required_argument, NULL, 'D' },
|
|
{ "packable", no_argument, NULL, 'p' },
|
|
{ NULL, 0, NULL, 0, }
|
|
};
|
|
|
|
static void usage(void)
|
|
{
|
|
fprintf(stderr,
|
|
"usage: pahole [options] <file_name> {<function_name>}\n"
|
|
" where: \n"
|
|
" -h, --help show usage info\n"
|
|
" -B, --bit_holes <nr_holes> show only structs at least <nr_holes> bit holes\n"
|
|
" -H, --holes <nr_holes> show only structs at least <nr_holes> holes\n"
|
|
" -p, --packable show only structs that has holes that can be packed\n"
|
|
" -c, --cacheline_size <size> set cacheline size (default=%d)\n"
|
|
" -n, --nr_members show number of members\n"
|
|
" -N, --class_name_len show size of classes\n"
|
|
" -s, --sizes show size of classes\n"
|
|
" -t, --nr_definitions show how many times struct was defined\n"
|
|
" -D, --decl_exclude <prefix> exclude classes declared in files with prefix\n"
|
|
" -x, --exclude <prefix> exclude prefixed classes from reports\n"
|
|
" -X, --cu_exclude <prefix> exclude prefixed compilation units from reports\n",
|
|
DEFAULT_CACHELINE_SIZE);
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
int option, option_index;
|
|
struct cus *cus;
|
|
char *file_name;
|
|
char *class_name = NULL;
|
|
void (*formatter)(const struct structure *s) = class_formatter;
|
|
|
|
while ((option = getopt_long(argc, argv, "B:c:D:hH:nNpstx:X:",
|
|
long_options, &option_index)) >= 0)
|
|
switch (option) {
|
|
case 'c': cacheline_size = atoi(optarg); break;
|
|
case 'H': nr_holes = atoi(optarg); break;
|
|
case 'B': nr_bit_holes = atoi(optarg); break;
|
|
case 's': formatter = size_formatter; break;
|
|
case 'n': formatter = nr_members_formatter; break;
|
|
case 'N': formatter = class_name_len_formatter; break;
|
|
case 'p': show_packable = 1; break;
|
|
case 't': formatter = nr_definitions_formatter; break;
|
|
case 'D': decl_exclude_prefix = optarg;
|
|
decl_exclude_prefix_len = strlen(decl_exclude_prefix);
|
|
break;
|
|
case 'x': class__exclude_prefix = optarg;
|
|
class__exclude_prefix_len = strlen(class__exclude_prefix);
|
|
break;
|
|
case 'X': cu__exclude_prefix = optarg;
|
|
cu__exclude_prefix_len = strlen(cu__exclude_prefix);
|
|
break;
|
|
case 'h': usage(); return EXIT_SUCCESS;
|
|
default: usage(); return EXIT_FAILURE;
|
|
}
|
|
|
|
if (optind < argc) {
|
|
switch (argc - optind) {
|
|
case 1: file_name = argv[optind++]; break;
|
|
case 2: file_name = argv[optind++];
|
|
class_name = argv[optind++]; break;
|
|
default: usage(); return EXIT_FAILURE;
|
|
}
|
|
} else {
|
|
usage();
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
cus = cus__new(NULL, NULL);
|
|
if (cus == NULL) {
|
|
fputs("pahole: insufficient memory\n", stderr);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (cus__load(cus, file_name) != 0) {
|
|
fprintf(stderr, "pahole: couldn't load DWARF info from %s\n",
|
|
file_name);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
cus__for_each_cu(cus, cu_unique_iterator, NULL, cu__filter);
|
|
|
|
if (class_name != NULL) {
|
|
struct structure *s = structures__find(class_name);
|
|
|
|
if (s == NULL) {
|
|
printf("struct %s not found!\n", class_name);
|
|
return EXIT_FAILURE;
|
|
}
|
|
tag__print(&s->class->tag, s->class->cu, NULL, NULL);
|
|
} else
|
|
print_classes(formatter);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|