/* Copyright (C) 2006 Mandriva Conectiva S.A. Copyright (C) 2006 Arnaldo Carvalho de Melo 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 #include #include #include #include #include #include "dwarves.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; const struct cu *cu; uint32_t nr_files; }; static struct structure *structure__new(const struct class *class, const struct cu *cu) { struct structure *self = malloc(sizeof(*self)); if (self != NULL) { self->class = class; self->cu = cu; 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(class__name(pos->class), name) == 0) return pos; return NULL; } static void structures__add(const struct class *class, const struct cu *cu) { struct structure *str = structure__new(class, cu); if (str != NULL) list_add(&str->node, &structures__list); } static void nr_definitions_formatter(const struct structure *self) { printf("%s: %u\n", class__name(self->class), self->nr_files); } static void nr_members_formatter(const struct structure *self) { printf("%s: %u\n", class__name(self->class), class__nr_members(self->class)); } static void size_formatter(const struct structure *self) { printf("%s: %u %u\n", class__name(self->class), class__size(self->class), self->class->nr_holes); } static void class_name_len_formatter(const struct structure *self) { const char *name = class__name(self->class); printf("%s: %u\n", name, strlen(name)); } static void class_formatter(const struct structure *self) { tag__print(class__tag(self->class), self->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->type.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 cu *cu, const struct class *dup, const struct cu *dup_cu, char *hdr, const char *fmt, ...) { va_list args; if (!*hdr) printf("class: %s\nfirst: %s\ncurrent: %s\n", class__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, const struct cu *cu, struct class *dup, const struct cu *dup_cu) { char hdr = 0; if (class__size(self) != class__size(dup)) class__dupmsg(self, cu, dup, dup_cu, &hdr, "size: %u != %u\n", class__size(self), class__size(dup)); if (class__nr_members(self) != class__nr_members(dup)) class__dupmsg(self, cu, dup, dup_cu, &hdr, "nr_members: %u != %u\n", class__nr_members(self), class__nr_members(dup)); if (self->nr_holes != dup->nr_holes) class__dupmsg(self, cu, dup, dup_cu, &hdr, "nr_holes: %u != %u\n", self->nr_holes, dup->nr_holes); if (self->nr_bit_holes != dup->nr_bit_holes) class__dupmsg(self, cu, dup, dup_cu, &hdr, "nr_bit_holes: %u != %u\n", self->nr_bit_holes, dup->nr_bit_holes); if (self->padding != dup->padding) class__dupmsg(self, cu, dup, dup_cu, &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, void *cookie) { struct structure *str; struct class *class; const char *name; tag = tag__to_struct(tag, cu); if (tag == NULL) /* Not a structure */ return NULL; class = tag__class(tag); name = class__name(class); if (name == NULL) return NULL; if (class__is_declaration(class)) return NULL; if (class__exclude_prefix != NULL && strncmp(class__exclude_prefix, name, class__exclude_prefix_len) == 0) return NULL; if (decl_exclude_prefix != NULL && (tag->decl_file == NULL || strncmp(decl_exclude_prefix, tag->decl_file, decl_exclude_prefix_len) == 0)) return NULL; class__find_holes(class, cu); if (class->nr_holes < nr_holes || class->nr_bit_holes < nr_bit_holes) return NULL; str = structures__find(name); if (str != NULL) { class__chkdupdef(str->class, str->cu, class, cu); 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), cu); 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] {}\n" " where: \n" " -h, --help show usage info\n" " -B, --bit_holes show only structs at least bit holes\n" " -H, --holes show only structs at least holes\n" " -p, --packable show only structs that has holes that can be packed\n" " -c, --cacheline_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 exclude classes declared in files with prefix\n" " -x, --exclude exclude prefixed classes from reports\n" " -X, --cu_exclude 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(class__tag(s->class), s->cu, NULL, NULL); } else print_classes(formatter); return EXIT_SUCCESS; }