{
        struct perf_script *script = container_of(tool, struct perf_script, tool);
        struct perf_session *session = script->session;
-       struct evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
+       struct evsel *evsel = evlist__id2evsel(session->evlist, sample->id);
        struct thread *thread = NULL;
 
        if (evsel && !evsel->core.attr.sample_id_all) {
 
                goto next_event;
        }
 
-       evsel = perf_evlist__id2evsel(session->evlist, sample.id);
+       evsel = evlist__id2evsel(session->evlist, sample.id);
        assert(evsel != NULL);
 
        if (event->header.type == PERF_RECORD_SAMPLE) {
 
                return;
        }
 
-       evsel = perf_evlist__id2evsel(trace->evlist, sample->id);
+       evsel = evlist__id2evsel(trace->evlist, sample->id);
        if (evsel == NULL) {
                fprintf(trace->output, "Unknown tp ID %" PRIu64 ", skipping...\n", sample->id);
                return;
 
                }
 
                err = -1;
-               evsel = perf_evlist__id2evsel(evlist, sample.id);
+               evsel = evlist__id2evsel(evlist, sample.id);
                if (evsel == NULL) {
                        pr_debug("event with id %" PRIu64
                                 " doesn't map to an evsel\n", sample.id);
 
                return -1;
        }
 
-       evsel = perf_evlist__id2evsel(evlist, sample.id);
+       evsel = evlist__id2evsel(evlist, sample.id);
        if (evsel == switch_tracking->switch_evsel) {
                next_tid = evsel__intval(evsel, &sample, "next_pid");
                prev_tid = evsel__intval(evsel, &sample, "prev_pid");
 
        if (!id)
                return NULL;
 
-       sid = perf_evlist__id2sid(session->evlist, id);
+       sid = evlist__id2sid(session->evlist, id);
        if (!sid)
                return NULL;
 
        if (!id)
                return -EINVAL;
 
-       sid = perf_evlist__id2sid(session->evlist, id);
+       sid = evlist__id2sid(session->evlist, id);
        if (!sid)
                return -ENOENT;
 
 
        return perf_evlist__poll(&evlist->core, timeout);
 }
 
-struct perf_sample_id *perf_evlist__id2sid(struct evlist *evlist, u64 id)
+struct perf_sample_id *evlist__id2sid(struct evlist *evlist, u64 id)
 {
        struct hlist_head *head;
        struct perf_sample_id *sid;
        return NULL;
 }
 
-struct evsel *perf_evlist__id2evsel(struct evlist *evlist, u64 id)
+struct evsel *evlist__id2evsel(struct evlist *evlist, u64 id)
 {
        struct perf_sample_id *sid;
 
        if (evlist->core.nr_entries == 1 || !id)
                return evlist__first(evlist);
 
-       sid = perf_evlist__id2sid(evlist, id);
+       sid = evlist__id2sid(evlist, id);
        if (sid)
                return container_of(sid->evsel, struct evsel, core);
 
        return NULL;
 }
 
-struct evsel *perf_evlist__id2evsel_strict(struct evlist *evlist,
-                                               u64 id)
+struct evsel *evlist__id2evsel_strict(struct evlist *evlist, u64 id)
 {
        struct perf_sample_id *sid;
 
        if (!id)
                return NULL;
 
-       sid = perf_evlist__id2sid(evlist, id);
+       sid = evlist__id2sid(evlist, id);
        if (sid)
                return container_of(sid->evsel, struct evsel, core);
 
        return NULL;
 }
 
-static int perf_evlist__event2id(struct evlist *evlist,
-                                union perf_event *event, u64 *id)
+static int evlist__event2id(struct evlist *evlist, union perf_event *event, u64 *id)
 {
        const __u64 *array = event->sample.array;
        ssize_t n;
        return 0;
 }
 
-struct evsel *perf_evlist__event2evsel(struct evlist *evlist,
-                                           union perf_event *event)
+struct evsel *evlist__event2evsel(struct evlist *evlist, union perf_event *event)
 {
        struct evsel *first = evlist__first(evlist);
        struct hlist_head *head;
            event->header.type != PERF_RECORD_SAMPLE)
                return first;
 
-       if (perf_evlist__event2id(evlist, event, &id))
+       if (evlist__event2id(evlist, event, &id))
                return NULL;
 
        /* Synthesized events have an id of zero */
 
 int evlist__parse_sample(struct evlist *evlist, union perf_event *event, struct perf_sample *sample)
 {
-       struct evsel *evsel = perf_evlist__event2evsel(evlist, event);
+       struct evsel *evsel = evlist__event2evsel(evlist, event);
 
        if (!evsel)
                return -EFAULT;
 
 int evlist__parse_sample_timestamp(struct evlist *evlist, union perf_event *event, u64 *timestamp)
 {
-       struct evsel *evsel = perf_evlist__event2evsel(evlist, event);
+       struct evsel *evsel = evlist__event2evsel(evlist, event);
 
        if (!evsel)
                return -EFAULT;
 
 
 int evlist__poll(struct evlist *evlist, int timeout);
 
-struct evsel *perf_evlist__id2evsel(struct evlist *evlist, u64 id);
-struct evsel *perf_evlist__id2evsel_strict(struct evlist *evlist,
-                                               u64 id);
+struct evsel *evlist__id2evsel(struct evlist *evlist, u64 id);
+struct evsel *evlist__id2evsel_strict(struct evlist *evlist, u64 id);
 
-struct perf_sample_id *perf_evlist__id2sid(struct evlist *evlist, u64 id);
+struct perf_sample_id *evlist__id2sid(struct evlist *evlist, u64 id);
 
 void evlist__toggle_bkw_mmap(struct evlist *evlist, enum bkw_mmap_state state);
 
 
 struct evsel *evlist__find_evsel_by_str(struct evlist *evlist, const char *str);
 
-struct evsel *perf_evlist__event2evsel(struct evlist *evlist,
-                                           union perf_event *event);
+struct evsel *evlist__event2evsel(struct evlist *evlist, union perf_event *event);
 
 bool perf_evlist__exclude_kernel(struct evlist *evlist);
 
 
        for (i = 1; i < nr; i++) {
                struct evsel *counter;
 
-               counter = perf_evlist__id2evsel(leader->evlist, v[i].id);
+               counter = evlist__id2evsel(leader->evlist, v[i].id);
                if (!counter)
                        return -EINVAL;
 
 
 
        evlist = *pevlist;
 
-       evsel = perf_evlist__id2evsel(evlist, ev->id);
+       evsel = evlist__id2evsel(evlist, ev->id);
        if (evsel == NULL)
                return -EINVAL;
 
 
 static int intel_pt_process_switch(struct intel_pt *pt,
                                   struct perf_sample *sample)
 {
-       struct evsel *evsel;
        pid_t tid;
        int cpu, ret;
+       struct evsel *evsel = evlist__id2evsel(pt->session->evlist, sample->id);
 
-       evsel = perf_evlist__id2evsel(pt->session->evlist, sample->id);
        if (evsel != pt->switch_evsel)
                return 0;
 
 
                if (pyevent == NULL)
                        return PyErr_NoMemory();
 
-               evsel = perf_evlist__event2evsel(evlist, event);
+               evsel = evlist__event2evsel(evlist, event);
                if (!evsel) {
                        Py_INCREF(Py_None);
                        return Py_None;
 
        if (event->header.type == PERF_RECORD_SAMPLE &&
            sample->raw_size) {
                /* Handle event with raw data */
-               ev_bc000 = perf_evlist__event2evsel(session->evlist, event);
+               ev_bc000 = evlist__event2evsel(session->evlist, event);
                if (ev_bc000 &&
                    ev_bc000->core.attr.config == PERF_EVENT_CPUM_CF_DIAG)
                        err = s390_cpumcf_dumpctr(sf, sample);
 
        if (event->header.type != PERF_RECORD_SAMPLE)
                return;
 
-       ev_bc000 = perf_evlist__event2evsel(evlist, event);
+       ev_bc000 = evlist__event2evsel(evlist, event);
        if (ev_bc000 == NULL ||
            ev_bc000->core.attr.config != PERF_EVENT_CPUM_CF_DIAG)
                return;
 
                                struct sample_read_value *v,
                                struct machine *machine)
 {
-       struct perf_sample_id *sid = perf_evlist__id2sid(evlist, v->id);
+       struct perf_sample_id *sid = evlist__id2sid(evlist, v->id);
        struct evsel *evsel;
 
        if (sid) {
 
        dump_event(evlist, event, file_offset, sample);
 
-       evsel = perf_evlist__id2evsel(evlist, sample->id);
+       evsel = evlist__id2evsel(evlist, sample->id);
 
        machine = machines__find_for_cpumode(machines, event, sample);
 
                        fprintf(stdout, "  tid: %"PRI_ld64"\n", e->tid);
                }
 
-               sid = perf_evlist__id2sid(evlist, e->id);
+               sid = evlist__id2sid(evlist, e->id);
                if (!sid)
                        return -ENOENT;
                sid->idx = e->idx;
 
                        if (perf_mmap__read_init(&map->core))
                                continue;
                        while ((event = perf_mmap__read_event(&map->core)) != NULL) {
-                               struct evsel *evsel = perf_evlist__event2evsel(evlist, event);
+                               struct evsel *evsel = evlist__event2evsel(evlist, event);
 
                                if (evsel && evsel->side_band.cb)
                                        evsel->side_band.cb(event, evsel->side_band.data);
 
        count.ena = st->ena;
        count.run = st->run;
 
-       counter = perf_evlist__id2evsel(session->evlist, st->id);
+       counter = evlist__id2evsel(session->evlist, st->id);
        if (!counter) {
                pr_err("Failed to resolve counter for stat event.\n");
                return -EINVAL;
 
 
                        e->id = evsel->core.id[j];
 
-                       sid = perf_evlist__id2sid(evlist, e->id);
+                       sid = evlist__id2sid(evlist, e->id);
                        if (!sid) {
                                free(ev);
                                return -ENOENT;