HEADER_BRANCH_STACK);
 
        if (annotate.group_set)
-               perf_evlist__force_leader(annotate.session->evlist);
+               evlist__force_leader(annotate.session->evlist);
 
        ret = symbol__annotation_init();
        if (ret < 0)
 
                        if ((errno == EINVAL || errno == EBADF) &&
                            pos->leader != pos &&
                            pos->weak_group) {
-                               pos = perf_evlist__reset_weak_group(evlist, pos, true);
+                               pos = evlist__reset_weak_group(evlist, pos, true);
                                goto try_again;
                        }
                        rc = -errno;
 
                                struct evlist *evlist)
 {
        if (report->group_set)
-               perf_evlist__force_leader(evlist);
+               evlist__force_leader(evlist);
 }
 
 static int process_feature_event(struct perf_session *session,
 
                                if ((errno == EINVAL || errno == EBADF) &&
                                    counter->leader != counter &&
                                    counter->weak_group) {
-                                       perf_evlist__reset_weak_group(evsel_list, counter, false);
+                                       evlist__reset_weak_group(evsel_list, counter, false);
                                        assert(counter->reset_group);
                                        second_pass = true;
                                        continue;
 
  * Make a group from 'leader' to 'last', requiring that the events were not
  * already grouped to a different leader.
  */
-static int perf_evlist__regroup(struct evlist *evlist,
-                               struct evsel *leader,
-                               struct evsel *last)
+static int evlist__regroup(struct evlist *evlist, struct evsel *leader, struct evsel *last)
 {
        struct evsel *evsel;
        bool grp;
                        evsel->core.attr.aux_sample_size = term->val.aux_sample_size;
                        /* If possible, group with the AUX event */
                        if (aux_evsel && evsel->core.attr.aux_sample_size)
-                               perf_evlist__regroup(evlist, aux_evsel, evsel);
+                               evlist__regroup(evlist, aux_evsel, evsel);
                }
        }
 
 
  * the group display. Set the artificial group and set the leader's
  * forced_leader flag to notify the display code.
  */
-void perf_evlist__force_leader(struct evlist *evlist)
+void evlist__force_leader(struct evlist *evlist)
 {
        if (!evlist->nr_groups) {
                struct evsel *leader = evlist__first(evlist);
        }
 }
 
-struct evsel *perf_evlist__reset_weak_group(struct evlist *evsel_list,
-                                                struct evsel *evsel,
-                                               bool close)
+struct evsel *evlist__reset_weak_group(struct evlist *evsel_list, struct evsel *evsel, bool close)
 {
        struct evsel *c2, *leader;
        bool is_open = true;
 
 
 bool perf_evlist__exclude_kernel(struct evlist *evlist);
 
-void perf_evlist__force_leader(struct evlist *evlist);
+void evlist__force_leader(struct evlist *evlist);
+
+struct evsel *evlist__reset_weak_group(struct evlist *evlist, struct evsel *evsel, bool close);
 
-struct evsel *perf_evlist__reset_weak_group(struct evlist *evlist,
-                                                struct evsel *evsel,
-                                               bool close);
 #define EVLIST_CTL_CMD_ENABLE_TAG  "enable"
 #define EVLIST_CTL_CMD_DISABLE_TAG "disable"
 #define EVLIST_CTL_CMD_ACK_TAG     "ack\n"