20 files changed, 250 insertions, 53 deletions

diff --git a/tools/perf/Documentation/perf-stat.txt b/tools/perf/Documentation/perf-stat.txt
index 5dfe102fb5b5..b10a90b6a718 100644
--- a/tools/perf/Documentation/perf-stat.txt
+++ b/tools/perf/Documentation/perf-stat.txt
@@ -178,6 +178,9 @@ Print count deltas for fixed number of times.
 This option should be used together with "-I" option.
         example: 'perf stat -I 1000 --interval-count 2 -e cycles -a'
 
+--interval-clear::
+Clear the screen before next interval.
+
 --timeout msecs::
 Stop the 'perf stat' session and print count deltas after N milliseconds (minimum: 10 ms).
 This option is not supported with the "-I" option.
diff --git a/tools/perf/arch/powerpc/util/skip-callchain-idx.c b/tools/perf/arch/powerpc/util/skip-callchain-idx.c
index 3598b8b75d27..ef5d59a5742e 100644
--- a/tools/perf/arch/powerpc/util/skip-callchain-idx.c
+++ b/tools/perf/arch/powerpc/util/skip-callchain-idx.c
@@ -243,7 +243,7 @@ int arch_skip_callchain_idx(struct thread *thread, struct ip_callchain *chain)
         u64 ip;
         u64 skip_slot = -1;
 
-        if (chain->nr < 3)
+        if (!chain || chain->nr < 3)
                 return skip_slot;
 
         ip = chain->ips[2];
diff --git a/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl b/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl
index 4dfe42666d0c..f0b1709a5ffb 100644
--- a/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl
+++ b/tools/perf/arch/x86/entry/syscalls/syscall_64.tbl
@@ -341,6 +341,8 @@
 330     common  pkey_alloc              __x64_sys_pkey_alloc
 331     common  pkey_free               __x64_sys_pkey_free
 332     common  statx                   __x64_sys_statx
+333     common  io_pgetevents           __x64_sys_io_pgetevents
+334     common  rseq                    __x64_sys_rseq
 
 #
 # x32-specific system call numbers start at 512 to avoid cache impact
diff --git a/tools/perf/bench/numa.c b/tools/perf/bench/numa.c
index 63eb49082774..44195514b19e 100644
--- a/tools/perf/bench/numa.c
+++ b/tools/perf/bench/numa.c
@@ -1098,7 +1098,7 @@ static void *worker_thread(void *__tdata)
         u8 *global_data;
         u8 *process_data;
         u8 *thread_data;
-        u64 bytes_done;
+        u64 bytes_done, secs;
         long work_done;
         u32 l;
         struct rusage rusage;
@@ -1254,7 +1254,8 @@ static void *worker_thread(void *__tdata)
         timersub(&stop, &start0, &diff);
         td->runtime_ns = diff.tv_sec * NSEC_PER_SEC;
         td->runtime_ns += diff.tv_usec * NSEC_PER_USEC;
-        td->speed_gbs = bytes_done / (td->runtime_ns / NSEC_PER_SEC) / 1e9;
+        secs = td->runtime_ns / NSEC_PER_SEC;
+        td->speed_gbs = secs ? bytes_done / secs / 1e9 : 0;
 
         getrusage(RUSAGE_THREAD, &rusage);
         td->system_time_ns = rusage.ru_stime.tv_sec * NSEC_PER_SEC;
diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 5eb22cc56363..8180319285af 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -283,6 +283,15 @@ out_put:
         return ret;
 }
 
+static int process_feature_event(struct perf_tool *tool,
+                                 union perf_event *event,
+                                 struct perf_session *session)
+{
+        if (event->feat.feat_id < HEADER_LAST_FEATURE)
+                return perf_event__process_feature(tool, event, session);
+        return 0;
+}
+
 static int hist_entry__tty_annotate(struct hist_entry *he,
                                     struct perf_evsel *evsel,
                                     struct perf_annotate *ann)
@@ -471,7 +480,7 @@ int cmd_annotate(int argc, const char **argv)
                         .attr   = perf_event__process_attr,
                         .build_id = perf_event__process_build_id,
                         .tracing_data   = perf_event__process_tracing_data,
-                        .feature        = perf_event__process_feature,
+                        .feature        = process_feature_event,
                         .ordered_events = true,
                         .ordering_requires_timestamps = true,
                 },
diff --git a/tools/perf/builtin-c2c.c b/tools/perf/builtin-c2c.c
index 307b3594525f..6a8738f7ead3 100644
--- a/tools/perf/builtin-c2c.c
+++ b/tools/perf/builtin-c2c.c
@@ -56,16 +56,16 @@ struct c2c_hist_entry {
 
         struct compute_stats     cstats;
 
+        unsigned long            paddr;
+        unsigned long            paddr_cnt;
+        bool                     paddr_zero;
+        char                    *nodestr;
+
         /*
          * must be at the end,
          * because of its callchain dynamic entry
          */
         struct hist_entry       he;
-
-        unsigned long            paddr;
-        unsigned long            paddr_cnt;
-        bool                     paddr_zero;
-        char                    *nodestr;
 };
 
 static char const *coalesce_default = "pid,iaddr";
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index cdb5b6949832..c04dc7b53797 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -217,7 +217,8 @@ static int process_feature_event(struct perf_tool *tool,
         }
 
         /*
-         * All features are received, we can force the
+         * (feat_id = HEADER_LAST_FEATURE) is the end marker which
+         * means all features are received, now we can force the
          * group if needed.
          */
         setup_forced_leader(rep, session->evlist);
diff --git a/tools/perf/builtin-script.c b/tools/perf/builtin-script.c
index b3bf35512d21..568ddfac3213 100644
--- a/tools/perf/builtin-script.c
+++ b/tools/perf/builtin-script.c
@@ -180,6 +180,18 @@ static struct {
                                   PERF_OUTPUT_EVNAME | PERF_OUTPUT_TRACE
         },
 
+        [PERF_TYPE_HW_CACHE] = {
+                .user_set = false,
+
+                .fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
+                              PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
+                              PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
+                              PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
+                              PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD,
+
+                .invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
+        },
+
         [PERF_TYPE_RAW] = {
                 .user_set = false,
 
@@ -1822,6 +1834,7 @@ static int process_attr(struct perf_tool *tool, union perf_event *event,
         struct perf_evlist *evlist;
         struct perf_evsel *evsel, *pos;
         int err;
+        static struct perf_evsel_script *es;
 
         err = perf_event__process_attr(tool, event, pevlist);
         if (err)
@@ -1830,6 +1843,19 @@ static int process_attr(struct perf_tool *tool, union perf_event *event,
         evlist = *pevlist;
         evsel = perf_evlist__last(*pevlist);
 
+        if (!evsel->priv) {
+                if (scr->per_event_dump) {
+                        evsel->priv = perf_evsel_script__new(evsel,
+                                                scr->session->data);
+                } else {
+                        es = zalloc(sizeof(*es));
+                        if (!es)
+                                return -ENOMEM;
+                        es->fp = stdout;
+                        evsel->priv = es;
+                }
+        }
+
         if (evsel->attr.type >= PERF_TYPE_MAX &&
             evsel->attr.type != PERF_TYPE_SYNTH)
                 return 0;
@@ -3018,6 +3044,15 @@ int process_cpu_map_event(struct perf_tool *tool __maybe_unused,
         return set_maps(script);
 }
 
+static int process_feature_event(struct perf_tool *tool,
+                                 union perf_event *event,
+                                 struct perf_session *session)
+{
+        if (event->feat.feat_id < HEADER_LAST_FEATURE)
+                return perf_event__process_feature(tool, event, session);
+        return 0;
+}
+
 #ifdef HAVE_AUXTRACE_SUPPORT
 static int perf_script__process_auxtrace_info(struct perf_tool *tool,
                                               union perf_event *event,
@@ -3062,7 +3097,7 @@ int cmd_script(int argc, const char **argv)
                         .attr            = process_attr,
                         .event_update   = perf_event__process_event_update,
                         .tracing_data    = perf_event__process_tracing_data,
-                        .feature         = perf_event__process_feature,
+                        .feature         = process_feature_event,
                         .build_id        = perf_event__process_build_id,
                         .id_index        = perf_event__process_id_index,
                         .auxtrace_info   = perf_script__process_auxtrace_info,
@@ -3113,8 +3148,9 @@ int cmd_script(int argc, const char **argv)
                      "+field to add and -field to remove."
                      "Valid types: hw,sw,trace,raw,synth. "
                      "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
-                     "addr,symoff,period,iregs,uregs,brstack,brstacksym,flags,"
-                     "bpf-output,callindent,insn,insnlen,brstackinsn,synth,phys_addr",
+                     "addr,symoff,srcline,period,iregs,uregs,brstack,"
+                     "brstacksym,flags,bpf-output,brstackinsn,brstackoff,"
+                     "callindent,insn,insnlen,synth,phys_addr,metric,misc",
                      parse_output_fields),
         OPT_BOOLEAN('a', "all-cpus", &system_wide,
                     "system-wide collection from all CPUs"),
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 096ccb25c11f..22547a490e1f 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -65,6 +65,7 @@
 #include "util/tool.h"
 #include "util/string2.h"
 #include "util/metricgroup.h"
+#include "util/top.h"
 #include "asm/bug.h"
 
 #include <linux/time64.h>
@@ -144,6 +145,8 @@ static struct target target = {
 
 typedef int (*aggr_get_id_t)(struct cpu_map *m, int cpu);
 
+#define METRIC_ONLY_LEN 20
+
 static int                      run_count                       =  1;
 static bool                     no_inherit                      = false;
 static volatile pid_t           child_pid                       = -1;
@@ -173,6 +176,7 @@ static struct cpu_map		*aggr_map;
 static aggr_get_id_t            aggr_get_id;
 static bool                     append_file;
 static bool                     interval_count;
+static bool                     interval_clear;
 static const char               *output_name;
 static int                      output_fd;
 static int                      print_free_counters_hint;
@@ -180,6 +184,7 @@ static int			print_mixed_hw_group_error;
 static u64                      *walltime_run;
 static bool                     ru_display                      = false;
 static struct rusage            ru_data;
+static unsigned int             metric_only_len                 = METRIC_ONLY_LEN;
 
 struct perf_stat {
         bool                     record;
@@ -967,8 +972,6 @@ static void print_metric_csv(void *ctx,
         fprintf(out, "%s%s%s%s", csv_sep, vals, csv_sep, unit);
 }
 
-#define METRIC_ONLY_LEN 20
-
 /* Filter out some columns that don't work well in metrics only mode */
 
 static bool valid_only_metric(const char *unit)
@@ -999,22 +1002,20 @@ static void print_metric_only(void *ctx, const char *color, const char *fmt,
 {
         struct outstate *os = ctx;
         FILE *out = os->fh;
-        int n;
-        char buf[1024];
-        unsigned mlen = METRIC_ONLY_LEN;
+        char buf[1024], str[1024];
+        unsigned mlen = metric_only_len;
 
         if (!valid_only_metric(unit))
                 return;
         unit = fixunit(buf, os->evsel, unit);
-        if (color)
-                n = color_fprintf(out, color, fmt, val);
-        else
-                n = fprintf(out, fmt, val);
-        if (n > METRIC_ONLY_LEN)
-                n = METRIC_ONLY_LEN;
         if (mlen < strlen(unit))
                 mlen = strlen(unit) + 1;
-        fprintf(out, "%*s", mlen - n, "");
+
+        if (color)
+                mlen += strlen(color) + sizeof(PERF_COLOR_RESET) - 1;
+
+        color_snprintf(str, sizeof(str), color ?: "", fmt, val);
+        fprintf(out, "%*s ", mlen, str);
 }
 
 static void print_metric_only_csv(void *ctx, const char *color __maybe_unused,
@@ -1054,7 +1055,7 @@ static void print_metric_header(void *ctx, const char *color __maybe_unused,
         if (csv_output)
                 fprintf(os->fh, "%s%s", unit, csv_sep);
         else
-                fprintf(os->fh, "%-*s ", METRIC_ONLY_LEN, unit);
+                fprintf(os->fh, "%*s ", metric_only_len, unit);
 }
 
 static void nsec_printout(int id, int nr, struct perf_evsel *evsel, double avg)
@@ -1704,9 +1705,12 @@ static void print_interval(char *prefix, struct timespec *ts)
         FILE *output = stat_config.output;
         static int num_print_interval;
 
+        if (interval_clear)
+                puts(CONSOLE_CLEAR);
+
         sprintf(prefix, "%6lu.%09lu%s", ts->tv_sec, ts->tv_nsec, csv_sep);
 
-        if (num_print_interval == 0 && !csv_output) {
+        if ((num_print_interval == 0 && !csv_output) || interval_clear) {
                 switch (stat_config.aggr_mode) {
                 case AGGR_SOCKET:
                         fprintf(output, "#           time socket cpus");
@@ -1719,7 +1723,7 @@ static void print_interval(char *prefix, struct timespec *ts)
                                 fprintf(output, "             counts %*s events\n", unit_width, "unit");
                         break;
                 case AGGR_NONE:
-                        fprintf(output, "#           time CPU");
+                        fprintf(output, "#           time CPU    ");
                         if (!metric_only)
                                 fprintf(output, "                counts %*s events\n", unit_width, "unit");
                         break;
@@ -1738,7 +1742,7 @@ static void print_interval(char *prefix, struct timespec *ts)
                 }
         }
 
-        if (num_print_interval == 0 && metric_only)
+        if ((num_print_interval == 0 && metric_only) || interval_clear)
                 print_metric_headers(" ", true);
         if (++num_print_interval == 25)
                 num_print_interval = 0;
@@ -2057,6 +2061,8 @@ static const struct option stat_options[] = {
                     "(overhead is possible for values <= 100ms)"),
         OPT_INTEGER(0, "interval-count", &stat_config.times,
                     "print counts for fixed number of times"),
+        OPT_BOOLEAN(0, "interval-clear", &interval_clear,
+                    "clear screen in between new interval"),
         OPT_UINTEGER(0, "timeout", &stat_config.timeout,
                     "stop workload and print counts after a timeout period in ms (>= 10ms)"),
         OPT_SET_UINT(0, "per-socket", &stat_config.aggr_mode,
@@ -2436,14 +2442,13 @@ static int add_default_attributes(void)
         (PERF_COUNT_HW_CACHE_OP_PREFETCH        <<  8) |
         (PERF_COUNT_HW_CACHE_RESULT_MISS        << 16)                          },
 };
+        struct parse_events_error errinfo;
 
         /* Set attrs if no event is selected and !null_run: */
         if (null_run)
                 return 0;
 
         if (transaction_run) {
-                struct parse_events_error errinfo;
-
                 if (pmu_have_event("cpu", "cycles-ct") &&
                     pmu_have_event("cpu", "el-start"))
                         err = parse_events(evsel_list, transaction_attrs,
@@ -2454,6 +2459,7 @@ static int add_default_attributes(void)
                                            &errinfo);
                 if (err) {
                         fprintf(stderr, "Cannot set up transaction events\n");
+                        parse_events_print_error(&errinfo, transaction_attrs);
                         return -1;
                 }
                 return 0;
@@ -2479,10 +2485,11 @@ static int add_default_attributes(void)
                     pmu_have_event("msr", "smi")) {
                         if (!force_metric_only)
                                 metric_only = true;
-                        err = parse_events(evsel_list, smi_cost_attrs, NULL);
+                        err = parse_events(evsel_list, smi_cost_attrs, &errinfo);
                 } else {
                         fprintf(stderr, "To measure SMI cost, it needs "
                                 "msr/aperf/, msr/smi/ and cpu/cycles/ support\n");
+                        parse_events_print_error(&errinfo, smi_cost_attrs);
                         return -1;
                 }
                 if (err) {
@@ -2517,12 +2524,13 @@ static int add_default_attributes(void)
                 if (topdown_attrs[0] && str) {
                         if (warn)
                                 arch_topdown_group_warn();
-                        err = parse_events(evsel_list, str, NULL);
+                        err = parse_events(evsel_list, str, &errinfo);
                         if (err) {
                                 fprintf(stderr,
                                         "Cannot set up top down events %s: %d\n",
                                         str, err);
                                 free(str);
+                                parse_events_print_error(&errinfo, str);
                                 return -1;
                         }
                 } else {
diff --git a/tools/perf/tests/parse-events.c b/tools/perf/tests/parse-events.c
index 7d4077068454..61211918bfba 100644
--- a/tools/perf/tests/parse-events.c
+++ b/tools/perf/tests/parse-events.c
@@ -1309,6 +1309,11 @@ static int test__checkevent_config_cache(struct perf_evlist *evlist)
         return 0;
 }
 
+static bool test__intel_pt_valid(void)
+{
+        return !!perf_pmu__find("intel_pt");
+}
+
 static int test__intel_pt(struct perf_evlist *evlist)
 {
         struct perf_evsel *evsel = perf_evlist__first(evlist);
@@ -1375,6 +1380,7 @@ struct evlist_test {
         const char *name;
         __u32 type;
         const int id;
+        bool (*valid)(void);
         int (*check)(struct perf_evlist *evlist);
 };
 
@@ -1648,6 +1654,7 @@ static struct evlist_test test__events[] = {
         },
         {
                 .name  = "intel_pt//u",
+                .valid = test__intel_pt_valid,
                 .check = test__intel_pt,
                 .id    = 52,
         },
@@ -1686,17 +1693,24 @@ static struct terms_test test__terms[] = {
 
 static int test_event(struct evlist_test *e)
 {
+        struct parse_events_error err = { .idx = 0, };
         struct perf_evlist *evlist;
         int ret;
 
+        if (e->valid && !e->valid()) {
+                pr_debug("... SKIP");
+                return 0;
+        }
+
         evlist = perf_evlist__new();
         if (evlist == NULL)
                 return -ENOMEM;
 
-        ret = parse_events(evlist, e->name, NULL);
+        ret = parse_events(evlist, e->name, &err);
         if (ret) {
-                pr_debug("failed to parse event '%s', err %d\n",
-                         e->name, ret);
+                pr_debug("failed to parse event '%s', err %d, str '%s'\n",
+                         e->name, ret, err.str);
+                parse_events_print_error(&err, e->name);
         } else {
                 ret = e->check(evlist);
         }
@@ -1714,10 +1728,11 @@ static int test_events(struct evlist_test *events, unsigned cnt)
         for (i = 0; i < cnt; i++) {
                 struct evlist_test *e = &events[i];
 
-                pr_debug("running test %d '%s'\n", e->id, e->name);
+                pr_debug("running test %d '%s'", e->id, e->name);
                 ret1 = test_event(e);
                 if (ret1)
                         ret2 = ret1;
+                pr_debug("\n");
         }
 
         return ret2;
@@ -1799,7 +1814,7 @@ static int test_pmu_events(void)
         }
 
         while (!ret && (ent = readdir(dir))) {
-                struct evlist_test e;
+                struct evlist_test e = { .id = 0, };
                 char name[2 * NAME_MAX + 1 + 12 + 3];
 
                 /* Names containing . are special and cannot be used directly */
diff --git a/tools/perf/tests/topology.c b/tools/perf/tests/topology.c
index 40e30a26b23c..9497d02f69e6 100644
--- a/tools/perf/tests/topology.c
+++ b/tools/perf/tests/topology.c
@@ -45,6 +45,7 @@ static int session_write_header(char *path)
 
         perf_header__set_feat(&session->header, HEADER_CPU_TOPOLOGY);
         perf_header__set_feat(&session->header, HEADER_NRCPUS);
+        perf_header__set_feat(&session->header, HEADER_ARCH);
 
         session->header.data_size += DATA_SIZE;
 
diff --git a/tools/perf/ui/gtk/hists.c b/tools/perf/ui/gtk/hists.c
index b085f1b3e34d..4ab663ec3e5e 100644
--- a/tools/perf/ui/gtk/hists.c
+++ b/tools/perf/ui/gtk/hists.c
@@ -382,7 +382,7 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists,
                         gtk_tree_store_set(store, &iter, col_idx++, s, -1);
                 }
 
-                if (hists__has_callchains(hists) &&
+                if (hist_entry__has_callchains(h) &&
                     symbol_conf.use_callchain && hists__has(hists, sym)) {
                         if (callchain_param.mode == CHAIN_GRAPH_REL)
                                 total = symbol_conf.cumulate_callchain ?
diff --git a/tools/perf/util/c++/clang.cpp b/tools/perf/util/c++/clang.cpp
index bf31ceab33bd..89512504551b 100644
--- a/tools/perf/util/c++/clang.cpp
+++ b/tools/perf/util/c++/clang.cpp
@@ -146,8 +146,15 @@ getBPFObjectFromModule(llvm::Module *Module)
         raw_svector_ostream ostream(*Buffer);
 
         legacy::PassManager PM;
-        if (TargetMachine->addPassesToEmitFile(PM, ostream,
-                                               TargetMachine::CGFT_ObjectFile)) {
+        bool NotAdded;
+#if CLANG_VERSION_MAJOR < 7
+        NotAdded = TargetMachine->addPassesToEmitFile(PM, ostream,
+                                                      TargetMachine::CGFT_ObjectFile);
+#else
+        NotAdded = TargetMachine->addPassesToEmitFile(PM, ostream, nullptr,
+                                                      TargetMachine::CGFT_ObjectFile);
+#endif
+        if (NotAdded) {
                 llvm::errs() << "TargetMachine can't emit a file of this type\n";
                 return std::unique_ptr<llvm::SmallVectorImpl<char>>(nullptr);;
         }
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 540cd2dcd3e7..653ff65aa2c3 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -2129,6 +2129,7 @@ static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
         int cpu_nr = ff->ph->env.nr_cpus_avail;
         u64 size = 0;
         struct perf_header *ph = ff->ph;
+        bool do_core_id_test = true;
 
         ph->env.cpu = calloc(cpu_nr, sizeof(*ph->env.cpu));
         if (!ph->env.cpu)
@@ -2183,6 +2184,13 @@ static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
                 return 0;
         }
 
+        /* On s390 the socket_id number is not related to the numbers of cpus.
+         * The socket_id number might be higher than the numbers of cpus.
+         * This depends on the configuration.
+         */
+        if (ph->env.arch && !strncmp(ph->env.arch, "s390", 4))
+                do_core_id_test = false;
+
         for (i = 0; i < (u32)cpu_nr; i++) {
                 if (do_read_u32(ff, &nr))
                         goto free_cpu;
@@ -2192,7 +2200,7 @@ static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
                 if (do_read_u32(ff, &nr))
                         goto free_cpu;
 
-                if (nr != (u32)-1 && nr > (u32)cpu_nr) {
+                if (do_core_id_test && nr != (u32)-1 && nr > (u32)cpu_nr) {
                         pr_debug("socket_id number is too big."
                                  "You may need to upgrade the perf tool.\n");
                         goto free_cpu;
@@ -3456,7 +3464,7 @@ int perf_event__process_feature(struct perf_tool *tool,
                 pr_warning("invalid record type %d in pipe-mode\n", type);
                 return 0;
         }
-        if (feat == HEADER_RESERVED || feat > HEADER_LAST_FEATURE) {
+        if (feat == HEADER_RESERVED || feat >= HEADER_LAST_FEATURE) {
                 pr_warning("invalid record type %d in pipe-mode\n", type);
                 return -1;
         }
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 52e8fda93a47..828cb9794c76 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -370,9 +370,11 @@ void hists__delete_entries(struct hists *hists)
 
 static int hist_entry__init(struct hist_entry *he,
                             struct hist_entry *template,
-                            bool sample_self)
+                            bool sample_self,
+                            size_t callchain_size)
 {
         *he = *template;
+        he->callchain_size = callchain_size;
 
         if (symbol_conf.cumulate_callchain) {
                 he->stat_acc = malloc(sizeof(he->stat));
@@ -473,7 +475,7 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template,
 
         he = ops->new(callchain_size);
         if (he) {
-                err = hist_entry__init(he, template, sample_self);
+                err = hist_entry__init(he, template, sample_self, callchain_size);
                 if (err) {
                         ops->free(he);
                         he = NULL;
@@ -619,9 +621,11 @@ __hists__add_entry(struct hists *hists,
                 .raw_data = sample->raw_data,
                 .raw_size = sample->raw_size,
                 .ops = ops,
-        };
+        }, *he = hists__findnew_entry(hists, &entry, al, sample_self);
 
-        return hists__findnew_entry(hists, &entry, al, sample_self);
+        if (!hists->has_callchains && he && he->callchain_size != 0)
+                hists->has_callchains = true;
+        return he;
 }
 
 struct hist_entry *hists__add_entry(struct hists *hists,
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 06607c434949..73049f7f0f60 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -85,6 +85,7 @@ struct hists {
         struct events_stats     stats;
         u64                     event_stream;
         u16                     col_len[HISTC_NR_COLS];
+        bool                    has_callchains;
         int                     socket_filter;
         struct perf_hpp_list    *hpp_list;
         struct list_head        hpp_formats;
@@ -222,8 +223,7 @@ static inline struct hists *evsel__hists(struct perf_evsel *evsel)
 
 static __pure inline bool hists__has_callchains(struct hists *hists)
 {
-        const struct perf_evsel *evsel = hists_to_evsel(hists);
-        return evsel__has_callchain(evsel);
+        return hists->has_callchains;
 }
 
 int hists__init(void);
diff --git a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
index ba4c9dd18643..d426761a549d 100644
--- a/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
+++ b/tools/perf/util/intel-pt-decoder/intel-pt-pkt-decoder.c
@@ -366,7 +366,7 @@ static int intel_pt_get_cyc(unsigned int byte, const unsigned char *buf,
                 if (len < offs)
                         return INTEL_PT_NEED_MORE_BYTES;
                 byte = buf[offs++];
-                payload |= (byte >> 1) << shift;
+                payload |= ((uint64_t)byte >> 1) << shift;
         }
 
         packet->type = INTEL_PT_CYC;
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index 155d2570274f..da8fe57691b8 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -227,11 +227,16 @@ event_def: event_pmu |
 event_pmu:
 PE_NAME opt_pmu_config
 {
+        struct parse_events_state *parse_state = _parse_state;
+        struct parse_events_error *error = parse_state->error;
         struct list_head *list, *orig_terms, *terms;
 
         if (parse_events_copy_term_list($2, &orig_terms))
                 YYABORT;
 
+        if (error)
+                error->idx = @1.first_column;
+
         ALLOC_LIST(list);
         if (parse_events_add_pmu(_parse_state, list, $1, $2, false, false)) {
                 struct perf_pmu *pmu = NULL;
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index d2fb597c9a8c..3ba6a1742f91 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -234,6 +234,74 @@ static int perf_pmu__parse_snapshot(struct perf_pmu_alias *alias,
         return 0;
 }
 
+static void perf_pmu_assign_str(char *name, const char *field, char **old_str,
+                                char **new_str)
+{
+        if (!*old_str)
+                goto set_new;
+
+        if (*new_str) { /* Have new string, check with old */
+                if (strcasecmp(*old_str, *new_str))
+                        pr_debug("alias %s differs in field '%s'\n",
+                                 name, field);
+                zfree(old_str);
+        } else          /* Nothing new --> keep old string */
+                return;
+set_new:
+        *old_str = *new_str;
+        *new_str = NULL;
+}
+
+static void perf_pmu_update_alias(struct perf_pmu_alias *old,
+                                  struct perf_pmu_alias *newalias)
+{
+        perf_pmu_assign_str(old->name, "desc", &old->desc, &newalias->desc);
+        perf_pmu_assign_str(old->name, "long_desc", &old->long_desc,
+                            &newalias->long_desc);
+        perf_pmu_assign_str(old->name, "topic", &old->topic, &newalias->topic);
+        perf_pmu_assign_str(old->name, "metric_expr", &old->metric_expr,
+                            &newalias->metric_expr);
+        perf_pmu_assign_str(old->name, "metric_name", &old->metric_name,
+                            &newalias->metric_name);
+        perf_pmu_assign_str(old->name, "value", &old->str, &newalias->str);
+        old->scale = newalias->scale;
+        old->per_pkg = newalias->per_pkg;
+        old->snapshot = newalias->snapshot;
+        memcpy(old->unit, newalias->unit, sizeof(old->unit));
+}
+
+/* Delete an alias entry. */
+static void perf_pmu_free_alias(struct perf_pmu_alias *newalias)
+{
+        zfree(&newalias->name);
+        zfree(&newalias->desc);
+        zfree(&newalias->long_desc);
+        zfree(&newalias->topic);
+        zfree(&newalias->str);
+        zfree(&newalias->metric_expr);
+        zfree(&newalias->metric_name);
+        parse_events_terms__purge(&newalias->terms);
+        free(newalias);
+}
+
+/* Merge an alias, search in alias list. If this name is already
+ * present merge both of them to combine all information.
+ */
+static bool perf_pmu_merge_alias(struct perf_pmu_alias *newalias,
+                                 struct list_head *alist)
+{
+        struct perf_pmu_alias *a;
+
+        list_for_each_entry(a, alist, list) {
+                if (!strcasecmp(newalias->name, a->name)) {
+                        perf_pmu_update_alias(a, newalias);
+                        perf_pmu_free_alias(newalias);
+                        return true;
+                }
+        }
+        return false;
+}
+
 static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
                                  char *desc, char *val,
                                  char *long_desc, char *topic,
@@ -241,9 +309,11 @@ static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
                                  char *metric_expr,
                                  char *metric_name)
 {
+        struct parse_events_term *term;
         struct perf_pmu_alias *alias;
         int ret;
         int num;
+        char newval[256];
 
         alias = malloc(sizeof(*alias));
         if (!alias)
@@ -262,6 +332,27 @@ static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
                 return ret;
         }
 
+        /* Scan event and remove leading zeroes, spaces, newlines, some
+         * platforms have terms specified as
+         * event=0x0091 (read from files ../<PMU>/events/<FILE>
+         * and terms specified as event=0x91 (read from JSON files).
+         *
+         * Rebuild string to make alias->str member comparable.
+         */
+        memset(newval, 0, sizeof(newval));
+        ret = 0;
+        list_for_each_entry(term, &alias->terms, list) {
+                if (ret)
+                        ret += scnprintf(newval + ret, sizeof(newval) - ret,
+                                         ",");
+                if (term->type_val == PARSE_EVENTS__TERM_TYPE_NUM)
+                        ret += scnprintf(newval + ret, sizeof(newval) - ret,
+                                         "%s=%#x", term->config, term->val.num);
+                else if (term->type_val == PARSE_EVENTS__TERM_TYPE_STR)
+                        ret += scnprintf(newval + ret, sizeof(newval) - ret,
+                                         "%s=%s", term->config, term->val.str);
+        }
+
         alias->name = strdup(name);
         if (dir) {
                 /*
@@ -285,9 +376,10 @@ static int __perf_pmu__new_alias(struct list_head *list, char *dir, char *name,
                 snprintf(alias->unit, sizeof(alias->unit), "%s", unit);
         }
         alias->per_pkg = perpkg && sscanf(perpkg, "%d", &num) == 1 && num == 1;
-        alias->str = strdup(val);
+        alias->str = strdup(newval);
 
-        list_add_tail(&alias->list, list);
+        if (!perf_pmu_merge_alias(alias, list))
+                list_add_tail(&alias->list, list);
 
         return 0;
 }
@@ -303,6 +395,9 @@ static int perf_pmu__new_alias(struct list_head *list, char *dir, char *name, FI
 
         buf[ret] = 0;
 
+        /* Remove trailing newline from sysfs file */
+        rtrim(buf);
+
         return __perf_pmu__new_alias(list, dir, name, NULL, buf, NULL, NULL, NULL,
                                      NULL, NULL, NULL);
 }
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 7cf2d5cc038e..8bf302cafcec 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -112,6 +112,8 @@ struct hist_entry {
 
         char                    level;
         u8                      filtered;
+
+        u16                     callchain_size;
         union {
                 /*
                  * Since perf diff only supports the stdio output, TUI
@@ -153,7 +155,7 @@ struct hist_entry {
 
 static __pure inline bool hist_entry__has_callchains(struct hist_entry *he)
 {
-        return hists__has_callchains(he->hists);
+        return he->callchain_size != 0;
 }
 
 static inline bool hist_entry__has_pairs(struct hist_entry *he)