if (rec->no_buildid)
                perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
 
-       if (!have_tracepoints(&rec->evlist->entries))
+       if (!have_tracepoints(&rec->evlist->core.entries))
                perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
 
        if (!rec->opts.branch_stack)
                        return err;
                }
 
-               if (have_tracepoints(&rec->evlist->entries)) {
+               if (have_tracepoints(&rec->evlist->core.entries)) {
                        /*
                         * FIXME err <= 0 here actually means that
                         * there were no tracepoints so its not really
 
        struct evsel *evsel;
        struct evsel_runtime *er;
 
-       list_for_each_entry(evsel, &evlist->entries, core.node) {
+       list_for_each_entry(evsel, &evlist->core.entries, core.node) {
                er = perf_evsel__get_runtime(evsel);
                if (er == NULL) {
                        pr_err("Failed to allocate memory for evsel runtime data\n");
 
 {
        struct trace *trace = opt->value;
 
-       if (!list_empty(&trace->evlist->entries))
+       if (!list_empty(&trace->evlist->core.entries))
                return parse_cgroups(opt, str, unset);
 
        trace->cgroup = evlist__findnew_cgroup(trace->evlist, str);
 
                        ui_browser__show_title(&menu->b, title);
                        switch (key) {
                        case K_TAB:
-                               if (pos->core.node.next == &evlist->entries)
+                               if (pos->core.node.next == &evlist->core.entries)
                                        pos = perf_evlist__first(evlist);
                                else
                                        pos = perf_evsel__next(pos);
                                goto browse_hists;
                        case K_UNTAB:
-                               if (pos->core.node.prev == &evlist->entries)
+                               if (pos->core.node.prev == &evlist->core.entries)
                                        pos = perf_evlist__last(evlist);
                                else
                                        pos = perf_evsel__prev(pos);
        struct evsel *pos;
        struct evsel_menu menu = {
                .b = {
-                       .entries    = &evlist->entries,
+                       .entries    = &evlist->core.entries,
                        .refresh    = ui_browser__list_head_refresh,
                        .seek       = ui_browser__list_head_seek,
                        .write      = perf_evsel_menu__write,
 
        char *s;
        int ret, i;
 
-       if (list_empty(&evlist->entries)) {
+       if (list_empty(&evlist->core.entries)) {
                fprintf(stderr, "must define events before cgroups\n");
                return -1;
        }
 
 
        for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i)
                INIT_HLIST_HEAD(&evlist->heads[i]);
-       INIT_LIST_HEAD(&evlist->entries);
+       INIT_LIST_HEAD(&evlist->core.entries);
        perf_evlist__set_maps(evlist, cpus, threads);
        fdarray__init(&evlist->pollfd, 64);
        evlist->workload.pid = -1;
 void evlist__add(struct evlist *evlist, struct evsel *entry)
 {
        entry->evlist = evlist;
-       list_add_tail(&entry->core.node, &evlist->entries);
+       list_add_tail(&entry->core.node, &evlist->core.entries);
        entry->idx = evlist->nr_entries;
        entry->tracking = !entry->idx;
 
 {
        if (evlist->nr_entries) {
                evlist->nr_groups = evlist->nr_entries > 1 ? 1 : 0;
-               __perf_evlist__set_leader(&evlist->entries);
+               __perf_evlist__set_leader(&evlist->core.entries);
        }
 }
 
                        list_move_tail(&evsel->core.node, &move);
        }
 
-       list_splice(&move, &evlist->entries);
+       list_splice(&move, &evlist->core.entries);
 }
 
 void perf_evlist__set_tracking_event(struct evlist *evlist,
 
 #include <linux/list.h>
 #include <api/fd/array.h>
 #include <stdio.h>
+#include <internal/evlist.h>
 #include "../perf.h"
 #include "event.h"
 #include "evsel.h"
 #define PERF_EVLIST__HLIST_SIZE (1 << PERF_EVLIST__HLIST_BITS)
 
 struct evlist {
-       struct list_head entries;
+       struct perf_evlist core;
        struct hlist_head heads[PERF_EVLIST__HLIST_SIZE];
        int              nr_entries;
        int              nr_groups;
 
 static inline bool perf_evlist__empty(struct evlist *evlist)
 {
-       return list_empty(&evlist->entries);
+       return list_empty(&evlist->core.entries);
 }
 
 static inline struct evsel *perf_evlist__first(struct evlist *evlist)
 {
-       return list_entry(evlist->entries.next, struct evsel, core.node);
+       return list_entry(evlist->core.entries.next, struct evsel, core.node);
 }
 
 static inline struct evsel *perf_evlist__last(struct evlist *evlist)
 {
-       return list_entry(evlist->entries.prev, struct evsel, core.node);
+       return list_entry(evlist->core.entries.prev, struct evsel, core.node);
 }
 
 size_t perf_evlist__fprintf(struct evlist *evlist, FILE *fp);
  * @evsel: struct evsel iterator
  */
 #define evlist__for_each_entry(evlist, evsel) \
-       __evlist__for_each_entry(&(evlist)->entries, evsel)
+       __evlist__for_each_entry(&(evlist)->core.entries, evsel)
 
 /**
  * __evlist__for_each_entry_continue - continue iteration thru all the evsels
  * @evsel: struct evsel iterator
  */
 #define evlist__for_each_entry_continue(evlist, evsel) \
-       __evlist__for_each_entry_continue(&(evlist)->entries, evsel)
+       __evlist__for_each_entry_continue(&(evlist)->core.entries, evsel)
 
 /**
  * __evlist__for_each_entry_reverse - iterate thru all the evsels in reverse order
  * @evsel: struct evsel iterator
  */
 #define evlist__for_each_entry_reverse(evlist, evsel) \
-       __evlist__for_each_entry_reverse(&(evlist)->entries, evsel)
+       __evlist__for_each_entry_reverse(&(evlist)->core.entries, evsel)
 
 /**
  * __evlist__for_each_entry_safe - safely iterate thru all the evsels
  * @tmp: struct evsel temp iterator
  */
 #define evlist__for_each_entry_safe(evlist, tmp, evsel) \
-       __evlist__for_each_entry_safe(&(evlist)->entries, tmp, evsel)
+       __evlist__for_each_entry_safe(&(evlist)->core.entries, tmp, evsel)
 
 void perf_evlist__set_tracking_event(struct evlist *evlist,
                                     struct evsel *tracking_evsel);
 
        if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
                return -1;
 
-       return read_tracing_data(ff->fd, &evlist->entries);
+       return read_tracing_data(ff->fd, &evlist->core.entries);
 }
 
 static int write_build_id(struct feat_fd *ff,
         * - write the tracing data from the temp file
         *   to the pipe
         */
-       tdata = tracing_data_get(&evlist->entries, fd, true);
+       tdata = tracing_data_get(&evlist->core.entries, fd, true);
        if (!tdata)
                return -1;
 
 
                if (!last)
                        return 0;
 
-               if (last->core.node.prev == &evlist->entries)
+               if (last->core.node.prev == &evlist->core.entries)
                        return 0;
                last = list_entry(last->core.node.prev, struct evsel, core.node);
        } while (!last->cmdline_group_boundary);
 
        struct evlist *evlist = counter->evlist;
        struct evsel *alias;
 
-       alias = list_prepare_entry(counter, &(evlist->entries), core.node);
-       list_for_each_entry_continue (alias, &evlist->entries, core.node) {
+       alias = list_prepare_entry(counter, &(evlist->core.entries), core.node);
+       list_for_each_entry_continue (alias, &evlist->core.entries, core.node) {
                if (strcmp(perf_evsel__name(alias), perf_evsel__name(counter)) ||
                    alias->scale != counter->scale ||
                    alias->cgrp != counter->cgrp ||