1 files changed, 36 insertions, 27 deletions

diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 603f5610861b..b68a00ea4121 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -9,11 +9,9 @@
 static struct rb_root threads;
 static struct thread *last_match;
 
-void thread__init(struct thread *self, pid_t pid)
+void map_groups__init(struct map_groups *self)
 {
         int i;
-        self->pid = pid;
-        self->comm = NULL;
         for (i = 0; i < MAP__NR_TYPES; ++i) {
                 self->maps[i] = RB_ROOT;
                 INIT_LIST_HEAD(&self->removed_maps[i]);
@@ -25,7 +23,8 @@ static struct thread *thread__new(pid_t pid)
         struct thread *self = zalloc(sizeof(*self));
 
         if (self != NULL) {
-                thread__init(self, pid);
+                map_groups__init(&self->mg);
+                self->pid = pid;
                 self->comm = malloc(32);
                 if (self->comm)
                         snprintf(self->comm, 32, ":%d", self->pid);
@@ -55,10 +54,11 @@ int thread__comm_len(struct thread *self)
 
 static const char *map_type__name[MAP__NR_TYPES] = {
         [MAP__FUNCTION] = "Functions",
+        [MAP__VARIABLE] = "Variables",
 };
 
-static size_t __thread__fprintf_maps(struct thread *self,
-                                     enum map_type type, FILE *fp)
+static size_t __map_groups__fprintf_maps(struct map_groups *self,
+                                         enum map_type type, FILE *fp)
 {
         size_t printed = fprintf(fp, "%s:\n", map_type__name[type]);
         struct rb_node *nd;
@@ -76,16 +76,16 @@ static size_t __thread__fprintf_maps(struct thread *self,
         return printed;
 }
 
-size_t thread__fprintf_maps(struct thread *self, FILE *fp)
+size_t map_groups__fprintf_maps(struct map_groups *self, FILE *fp)
 {
         size_t printed = 0, i;
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __thread__fprintf_maps(self, i, fp);
+                printed += __map_groups__fprintf_maps(self, i, fp);
         return printed;
 }
 
-static size_t __thread__fprintf_removed_maps(struct thread *self,
-                                             enum map_type type, FILE *fp)
+static size_t __map_groups__fprintf_removed_maps(struct map_groups *self,
+                                                 enum map_type type, FILE *fp)
 {
         struct map *pos;
         size_t printed = 0;
@@ -101,20 +101,25 @@ static size_t __thread__fprintf_removed_maps(struct thread *self,
         return printed;
 }
 
-static size_t thread__fprintf_removed_maps(struct thread *self, FILE *fp)
+static size_t map_groups__fprintf_removed_maps(struct map_groups *self, FILE *fp)
 {
         size_t printed = 0, i;
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                printed += __thread__fprintf_removed_maps(self, i, fp);
+                printed += __map_groups__fprintf_removed_maps(self, i, fp);
         return printed;
 }
 
-static size_t thread__fprintf(struct thread *self, FILE *fp)
+static size_t map_groups__fprintf(struct map_groups *self, FILE *fp)
 {
-        size_t printed = fprintf(fp, "Thread %d %s\n", self->pid, self->comm);
-        printed += thread__fprintf_removed_maps(self, fp);
+        size_t printed = map_groups__fprintf_maps(self, fp);
         printed += fprintf(fp, "Removed maps:\n");
-        return printed + thread__fprintf_removed_maps(self, fp);
+        return printed + map_groups__fprintf_removed_maps(self, fp);
+}
+
+static size_t thread__fprintf(struct thread *self, FILE *fp)
+{
+        return fprintf(fp, "Thread %d %s\n", self->pid, self->comm) +
+               map_groups__fprintf(&self->mg, fp);
 }
 
 struct thread *threads__findnew(pid_t pid)
@@ -168,7 +173,8 @@ struct thread *register_idle_thread(void)
         return thread;
 }
 
-static void thread__remove_overlappings(struct thread *self, struct map *map)
+static void map_groups__remove_overlappings(struct map_groups *self,
+                                            struct map *map)
 {
         struct rb_root *root = &self->maps[map->type];
         struct rb_node *next = rb_first(root);
@@ -238,12 +244,15 @@ struct map *maps__find(struct rb_root *maps, u64 ip)
 
 void thread__insert_map(struct thread *self, struct map *map)
 {
-        thread__remove_overlappings(self, map);
-        maps__insert(&self->maps[map->type], map);
+        map_groups__remove_overlappings(&self->mg, map);
+        map_groups__insert(&self->mg, map);
 }
 
-static int thread__clone_maps(struct thread *self, struct thread *parent,
-                              enum map_type type)
+/*
+ * XXX This should not really _copy_ te maps, but refcount them.
+ */
+static int map_groups__clone(struct map_groups *self,
+                             struct map_groups *parent, enum map_type type)
 {
         struct rb_node *nd;
         for (nd = rb_first(&parent->maps[type]); nd; nd = rb_next(nd)) {
@@ -251,7 +260,7 @@ static int thread__clone_maps(struct thread *self, struct thread *parent,
                 struct map *new = map__clone(map);
                 if (new == NULL)
                         return -ENOMEM;
-                thread__insert_map(self, new);
+                map_groups__insert(self, new);
         }
         return 0;
 }
@@ -267,7 +276,7 @@ int thread__fork(struct thread *self, struct thread *parent)
                 return -ENOMEM;
 
         for (i = 0; i < MAP__NR_TYPES; ++i)
-                if (thread__clone_maps(self, parent, i) < 0)
+                if (map_groups__clone(&self->mg, &parent->mg, i) < 0)
                         return -ENOMEM;
         return 0;
 }
@@ -286,11 +295,11 @@ size_t threads__fprintf(FILE *fp)
         return ret;
 }
 
-struct symbol *thread__find_symbol(struct thread *self,
-                                   enum map_type type, u64 addr,
-                                   symbol_filter_t filter)
+struct symbol *map_groups__find_symbol(struct map_groups *self,
+                                       enum map_type type, u64 addr,
+                                       symbol_filter_t filter)
 {
-        struct map *map = thread__find_map(self, type, addr);
+        struct map *map = map_groups__find(self, type, addr);
 
         if (map != NULL)
                 return map__find_symbol(map, map->map_ip(map, addr), filter);