tools/perf/util/sort.c

   1 #include <sys/mman.h>
   2 #include "sort.h"
   3 #include "hist.h"
   4 #include "comm.h"
   5 #include "symbol.h"
   6 #include "evsel.h"
   7
   8 regex_t         parent_regex;
   9 const char      default_parent_pattern[] = "^sys_|^do_page_fault";
  10 const char      *parent_pattern = default_parent_pattern;
  11 const char      default_sort_order[] = "comm,dso,symbol";
  12 const char      default_branch_sort_order[] = "comm,dso_from,symbol_from,dso_to,symbol_to";
  13 const char      default_mem_sort_order[] = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked";
  14 const char      default_top_sort_order[] = "dso,symbol";
  15 const char      default_diff_sort_order[] = "dso,symbol";
  16 const char      *sort_order;
  17 const char      *field_order;
  18 regex_t         ignore_callees_regex;
  19 int             have_ignore_callees = 0;
  20 int             sort__need_collapse = 0;
  21 int             sort__has_parent = 0;
  22 int             sort__has_sym = 0;
  23 int             sort__has_dso = 0;
  24 enum sort_mode  sort__mode = SORT_MODE__NORMAL;
  25
  26
  27 static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
  28 {
  29         int n;
  30         va_list ap;
  31
  32         va_start(ap, fmt);
  33         n = vsnprintf(bf, size, fmt, ap);
  34         if (symbol_conf.field_sep && n > 0) {
  35                 char *sep = bf;
  36
  37                 while (1) {
  38                         sep = strchr(sep, *symbol_conf.field_sep);
  39                         if (sep == NULL)
  40                                 break;
  41                         *sep = '.';
  42                 }
  43         }
  44         va_end(ap);
  45
  46         if (n >= (int)size)
  47                 return size - 1;
  48         return n;
  49 }
  50
  51 static int64_t cmp_null(const void *l, const void *r)
  52 {
  53         if (!l && !r)
  54                 return 0;
  55         else if (!l)
  56                 return -1;
  57         else
  58                 return 1;
  59 }
  60
  61 /* --sort pid */
  62
  63 static int64_t
  64 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
  65 {
  66         return right->thread->tid - left->thread->tid;
  67 }
  68
  69 static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf,
  70                                        size_t size, unsigned int width)
  71 {
  72         const char *comm = thread__comm_str(he->thread);
  73
  74         width = max(7U, width) - 6;
  75         return repsep_snprintf(bf, size, "%5d:%-*.*s", he->thread->tid,
  76                                width, width, comm ?: "");
  77 }
  78
  79 struct sort_entry sort_thread = {
  80         .se_header      = "  Pid:Command",
  81         .se_cmp         = sort__thread_cmp,
  82         .se_snprintf    = hist_entry__thread_snprintf,
  83         .se_width_idx   = HISTC_THREAD,
  84 };
  85
  86 /* --sort comm */
  87
  88 static int64_t
  89 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
  90 {
  91         /* Compare the addr that should be unique among comm */
  92         return comm__str(right->comm) - comm__str(left->comm);
  93 }
  94
  95 static int64_t
  96 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
  97 {
  98         /* Compare the addr that should be unique among comm */
  99         return comm__str(right->comm) - comm__str(left->comm);
 100 }
 101
 102 static int64_t
 103 sort__comm_sort(struct hist_entry *left, struct hist_entry *right)
 104 {
 105         return strcmp(comm__str(right->comm), comm__str(left->comm));
 106 }
 107
 108 static int hist_entry__comm_snprintf(struct hist_entry *he, char *bf,
 109                                      size_t size, unsigned int width)
 110 {
 111         return repsep_snprintf(bf, size, "%-*.*s", width, width, comm__str(he->comm));
 112 }
 113
 114 struct sort_entry sort_comm = {
 115         .se_header      = "Command",
 116         .se_cmp         = sort__comm_cmp,
 117         .se_collapse    = sort__comm_collapse,
 118         .se_sort        = sort__comm_sort,
 119         .se_snprintf    = hist_entry__comm_snprintf,
 120         .se_width_idx   = HISTC_COMM,
 121 };
 122
 123 /* --sort dso */
 124
 125 static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
 126 {
 127         struct dso *dso_l = map_l ? map_l->dso : NULL;
 128         struct dso *dso_r = map_r ? map_r->dso : NULL;
 129         const char *dso_name_l, *dso_name_r;
 130
 131         if (!dso_l || !dso_r)
 132                 return cmp_null(dso_r, dso_l);
 133
 134         if (verbose) {
 135                 dso_name_l = dso_l->long_name;
 136                 dso_name_r = dso_r->long_name;
 137         } else {
 138                 dso_name_l = dso_l->short_name;
 139                 dso_name_r = dso_r->short_name;
 140         }
 141
 142         return strcmp(dso_name_l, dso_name_r);
 143 }
 144
 145 static int64_t
 146 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
 147 {
 148         return _sort__dso_cmp(right->ms.map, left->ms.map);
 149 }
 150
 151 static int _hist_entry__dso_snprintf(struct map *map, char *bf,
 152                                      size_t size, unsigned int width)
 153 {
 154         if (map && map->dso) {
 155                 const char *dso_name = !verbose ? map->dso->short_name :
 156                         map->dso->long_name;
 157                 return repsep_snprintf(bf, size, "%-*.*s", width, width, dso_name);
 158         }
 159
 160         return repsep_snprintf(bf, size, "%-*.*s", width, width, "[unknown]");
 161 }
 162
 163 static int hist_entry__dso_snprintf(struct hist_entry *he, char *bf,
 164                                     size_t size, unsigned int width)
 165 {
 166         return _hist_entry__dso_snprintf(he->ms.map, bf, size, width);
 167 }
 168
 169 struct sort_entry sort_dso = {
 170         .se_header      = "Shared Object",
 171         .se_cmp         = sort__dso_cmp,
 172         .se_snprintf    = hist_entry__dso_snprintf,
 173         .se_width_idx   = HISTC_DSO,
 174 };
 175
 176 /* --sort symbol */
 177
 178 static int64_t _sort__addr_cmp(u64 left_ip, u64 right_ip)
 179 {
 180         return (int64_t)(right_ip - left_ip);
 181 }
 182
 183 static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
 184 {
 185         u64 ip_l, ip_r;
 186
 187         if (!sym_l || !sym_r)
 188                 return cmp_null(sym_l, sym_r);
 189
 190         if (sym_l == sym_r)
 191                 return 0;
 192
 193         ip_l = sym_l->start;
 194         ip_r = sym_r->start;
 195
 196         return (int64_t)(ip_r - ip_l);
 197 }
 198
 199 static int64_t
 200 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
 201 {
 202         int64_t ret;
 203
 204         if (!left->ms.sym && !right->ms.sym)
 205                 return _sort__addr_cmp(left->ip, right->ip);
 206
 207         /*
 208          * comparing symbol address alone is not enough since it's a
 209          * relative address within a dso.
 210          */
 211         if (!sort__has_dso) {
 212                 ret = sort__dso_cmp(left, right);
 213                 if (ret != 0)
 214                         return ret;
 215         }
 216
 217         return _sort__sym_cmp(left->ms.sym, right->ms.sym);
 218 }
 219
 220 static int64_t
 221 sort__sym_sort(struct hist_entry *left, struct hist_entry *right)
 222 {
 223         if (!left->ms.sym || !right->ms.sym)
 224                 return cmp_null(left->ms.sym, right->ms.sym);
 225
 226         return strcmp(right->ms.sym->name, left->ms.sym->name);
 227 }
 228
 229 static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
 230                                      u64 ip, char level, char *bf, size_t size,
 231                                      unsigned int width)
 232 {
 233         size_t ret = 0;
 234
 235         if (verbose) {
 236                 char o = map ? dso__symtab_origin(map->dso) : '!';
 237                 ret += repsep_snprintf(bf, size, "%-#*llx %c ",
 238                                        BITS_PER_LONG / 4 + 2, ip, o);
 239         }
 240
 241         ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
 242         if (sym && map) {
 243                 if (map->type == MAP__VARIABLE) {
 244                         ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
 245                         ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
 246                                         ip - map->unmap_ip(map, sym->start));
 247                         ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
 248                                        width - ret, "");
 249                 } else {
 250                         ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
 251                                                width - ret,
 252                                                sym->name);
 253                 }
 254         } else {
 255                 size_t len = BITS_PER_LONG / 4;
 256                 ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
 257                                        len, ip);
 258                 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
 259                                        width - ret, "");
 260         }
 261
 262         if (ret > width)
 263                 bf[width] = '\0';
 264
 265         return width;
 266 }
 267
 268 static int hist_entry__sym_snprintf(struct hist_entry *he, char *bf,
 269                                     size_t size, unsigned int width)
 270 {
 271         return _hist_entry__sym_snprintf(he->ms.map, he->ms.sym, he->ip,
 272                                          he->level, bf, size, width);
 273 }
 274
 275 struct sort_entry sort_sym = {
 276         .se_header      = "Symbol",
 277         .se_cmp         = sort__sym_cmp,
 278         .se_sort        = sort__sym_sort,
 279         .se_snprintf    = hist_entry__sym_snprintf,
 280         .se_width_idx   = HISTC_SYMBOL,
 281 };
 282
 283 /* --sort srcline */
 284
 285 static int64_t
 286 sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
 287 {
 288         if (!left->srcline) {
 289                 if (!left->ms.map)
 290                         left->srcline = SRCLINE_UNKNOWN;
 291                 else {
 292                         struct map *map = left->ms.map;
 293                         left->srcline = get_srcline(map->dso,
 294                                            map__rip_2objdump(map, left->ip),
 295                                                     left->ms.sym, true);
 296                 }
 297         }
 298         if (!right->srcline) {
 299                 if (!right->ms.map)
 300                         right->srcline = SRCLINE_UNKNOWN;
 301                 else {
 302                         struct map *map = right->ms.map;
 303                         right->srcline = get_srcline(map->dso,
 304                                              map__rip_2objdump(map, right->ip),
 305                                                      right->ms.sym, true);
 306                 }
 307         }
 308         return strcmp(right->srcline, left->srcline);
 309 }
 310
 311 static int hist_entry__srcline_snprintf(struct hist_entry *he, char *bf,
 312                                         size_t size, unsigned int width)
 313 {
 314         return repsep_snprintf(bf, size, "%-*.*s", width, width, he->srcline);
 315 }
 316
 317 struct sort_entry sort_srcline = {
 318         .se_header      = "Source:Line",
 319         .se_cmp         = sort__srcline_cmp,
 320         .se_snprintf    = hist_entry__srcline_snprintf,
 321         .se_width_idx   = HISTC_SRCLINE,
 322 };
 323
 324 /* --sort parent */
 325
 326 static int64_t
 327 sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
 328 {
 329         struct symbol *sym_l = left->parent;
 330         struct symbol *sym_r = right->parent;
 331
 332         if (!sym_l || !sym_r)
 333                 return cmp_null(sym_l, sym_r);
 334
 335         return strcmp(sym_r->name, sym_l->name);
 336 }
 337
 338 static int hist_entry__parent_snprintf(struct hist_entry *he, char *bf,
 339                                        size_t size, unsigned int width)
 340 {
 341         return repsep_snprintf(bf, size, "%-*.*s", width, width,
 342                               he->parent ? he->parent->name : "[other]");
 343 }
 344
 345 struct sort_entry sort_parent = {
 346         .se_header      = "Parent symbol",
 347         .se_cmp         = sort__parent_cmp,
 348         .se_snprintf    = hist_entry__parent_snprintf,
 349         .se_width_idx   = HISTC_PARENT,
 350 };
 351
 352 /* --sort cpu */
 353
 354 static int64_t
 355 sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
 356 {
 357         return right->cpu - left->cpu;
 358 }
 359
 360 static int hist_entry__cpu_snprintf(struct hist_entry *he, char *bf,
 361                                     size_t size, unsigned int width)
 362 {
 363         return repsep_snprintf(bf, size, "%*.*d", width, width, he->cpu);
 364 }
 365
 366 struct sort_entry sort_cpu = {
 367         .se_header      = "CPU",
 368         .se_cmp         = sort__cpu_cmp,
 369         .se_snprintf    = hist_entry__cpu_snprintf,
 370         .se_width_idx   = HISTC_CPU,
 371 };
 372
 373 /* sort keys for branch stacks */
 374
 375 static int64_t
 376 sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
 377 {
 378         if (!left->branch_info || !right->branch_info)
 379                 return cmp_null(left->branch_info, right->branch_info);
 380
 381         return _sort__dso_cmp(left->branch_info->from.map,
 382                               right->branch_info->from.map);
 383 }
 384
 385 static int hist_entry__dso_from_snprintf(struct hist_entry *he, char *bf,
 386                                     size_t size, unsigned int width)
 387 {
 388         if (he->branch_info)
 389                 return _hist_entry__dso_snprintf(he->branch_info->from.map,
 390                                                  bf, size, width);
 391         else
 392                 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
 393 }
 394
 395 static int64_t
 396 sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
 397 {
 398         if (!left->branch_info || !right->branch_info)
 399                 return cmp_null(left->branch_info, right->branch_info);
 400
 401         return _sort__dso_cmp(left->branch_info->to.map,
 402                               right->branch_info->to.map);
 403 }
 404
 405 static int hist_entry__dso_to_snprintf(struct hist_entry *he, char *bf,
 406                                        size_t size, unsigned int width)
 407 {
 408         if (he->branch_info)
 409                 return _hist_entry__dso_snprintf(he->branch_info->to.map,
 410                                                  bf, size, width);
 411         else
 412                 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
 413 }
 414
 415 static int64_t
 416 sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
 417 {
 418         struct addr_map_symbol *from_l = &left->branch_info->from;
 419         struct addr_map_symbol *from_r = &right->branch_info->from;
 420
 421         if (!left->branch_info || !right->branch_info)
 422                 return cmp_null(left->branch_info, right->branch_info);
 423
 424         from_l = &left->branch_info->from;
 425         from_r = &right->branch_info->from;
 426
 427         if (!from_l->sym && !from_r->sym)
 428                 return _sort__addr_cmp(from_l->addr, from_r->addr);
 429
 430         return _sort__sym_cmp(from_l->sym, from_r->sym);
 431 }
 432
 433 static int64_t
 434 sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
 435 {
 436         struct addr_map_symbol *to_l, *to_r;
 437
 438         if (!left->branch_info || !right->branch_info)
 439                 return cmp_null(left->branch_info, right->branch_info);
 440
 441         to_l = &left->branch_info->to;
 442         to_r = &right->branch_info->to;
 443
 444         if (!to_l->sym && !to_r->sym)
 445                 return _sort__addr_cmp(to_l->addr, to_r->addr);
 446
 447         return _sort__sym_cmp(to_l->sym, to_r->sym);
 448 }
 449
 450 static int hist_entry__sym_from_snprintf(struct hist_entry *he, char *bf,
 451                                          size_t size, unsigned int width)
 452 {
 453         if (he->branch_info) {
 454                 struct addr_map_symbol *from = &he->branch_info->from;
 455
 456                 return _hist_entry__sym_snprintf(from->map, from->sym, from->addr,
 457                                                  he->level, bf, size, width);
 458         }
 459
 460         return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
 461 }
 462
 463 static int hist_entry__sym_to_snprintf(struct hist_entry *he, char *bf,
 464                                        size_t size, unsigned int width)
 465 {
 466         if (he->branch_info) {
 467                 struct addr_map_symbol *to = &he->branch_info->to;
 468
 469                 return _hist_entry__sym_snprintf(to->map, to->sym, to->addr,
 470                                                  he->level, bf, size, width);
 471         }
 472
 473         return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
 474 }
 475
 476 struct sort_entry sort_dso_from = {
 477         .se_header      = "Source Shared Object",
 478         .se_cmp         = sort__dso_from_cmp,
 479         .se_snprintf    = hist_entry__dso_from_snprintf,
 480         .se_width_idx   = HISTC_DSO_FROM,
 481 };
 482
 483 struct sort_entry sort_dso_to = {
 484         .se_header      = "Target Shared Object",
 485         .se_cmp         = sort__dso_to_cmp,
 486         .se_snprintf    = hist_entry__dso_to_snprintf,
 487         .se_width_idx   = HISTC_DSO_TO,
 488 };
 489
 490 struct sort_entry sort_sym_from = {
 491         .se_header      = "Source Symbol",
 492         .se_cmp         = sort__sym_from_cmp,
 493         .se_snprintf    = hist_entry__sym_from_snprintf,
 494         .se_width_idx   = HISTC_SYMBOL_FROM,
 495 };
 496
 497 struct sort_entry sort_sym_to = {
 498         .se_header      = "Target Symbol",
 499         .se_cmp         = sort__sym_to_cmp,
 500         .se_snprintf    = hist_entry__sym_to_snprintf,
 501         .se_width_idx   = HISTC_SYMBOL_TO,
 502 };
 503
 504 static int64_t
 505 sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
 506 {
 507         unsigned char mp, p;
 508
 509         if (!left->branch_info || !right->branch_info)
 510                 return cmp_null(left->branch_info, right->branch_info);
 511
 512         mp = left->branch_info->flags.mispred != right->branch_info->flags.mispred;
 513         p  = left->branch_info->flags.predicted != right->branch_info->flags.predicted;
 514         return mp || p;
 515 }
 516
 517 static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf,
 518                                     size_t size, unsigned int width){
 519         static const char *out = "N/A";
 520
 521         if (he->branch_info) {
 522                 if (he->branch_info->flags.predicted)
 523                         out = "N";
 524                 else if (he->branch_info->flags.mispred)
 525                         out = "Y";
 526         }
 527
 528         return repsep_snprintf(bf, size, "%-*.*s", width, width, out);
 529 }
 530
 531 /* --sort daddr_sym */
 532 static int64_t
 533 sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
 534 {
 535         uint64_t l = 0, r = 0;
 536
 537         if (left->mem_info)
 538                 l = left->mem_info->daddr.addr;
 539         if (right->mem_info)
 540                 r = right->mem_info->daddr.addr;
 541
 542         return (int64_t)(r - l);
 543 }
 544
 545 static int hist_entry__daddr_snprintf(struct hist_entry *he, char *bf,
 546                                     size_t size, unsigned int width)
 547 {
 548         uint64_t addr = 0;
 549         struct map *map = NULL;
 550         struct symbol *sym = NULL;
 551
 552         if (he->mem_info) {
 553                 addr = he->mem_info->daddr.addr;
 554                 map = he->mem_info->daddr.map;
 555                 sym = he->mem_info->daddr.sym;
 556         }
 557         return _hist_entry__sym_snprintf(map, sym, addr, he->level, bf, size,
 558                                          width);
 559 }
 560
 561 static int64_t
 562 sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
 563 {
 564         struct map *map_l = NULL;
 565         struct map *map_r = NULL;
 566
 567         if (left->mem_info)
 568                 map_l = left->mem_info->daddr.map;
 569         if (right->mem_info)
 570                 map_r = right->mem_info->daddr.map;
 571
 572         return _sort__dso_cmp(map_l, map_r);
 573 }
 574
 575 static int hist_entry__dso_daddr_snprintf(struct hist_entry *he, char *bf,
 576                                     size_t size, unsigned int width)
 577 {
 578         struct map *map = NULL;
 579
 580         if (he->mem_info)
 581                 map = he->mem_info->daddr.map;
 582
 583         return _hist_entry__dso_snprintf(map, bf, size, width);
 584 }
 585
 586 static int64_t
 587 sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
 588 {
 589         union perf_mem_data_src data_src_l;
 590         union perf_mem_data_src data_src_r;
 591
 592         if (left->mem_info)
 593                 data_src_l = left->mem_info->data_src;
 594         else
 595                 data_src_l.mem_lock = PERF_MEM_LOCK_NA;
 596
 597         if (right->mem_info)
 598                 data_src_r = right->mem_info->data_src;
 599         else
 600                 data_src_r.mem_lock = PERF_MEM_LOCK_NA;
 601
 602         return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
 603 }
 604
 605 static int hist_entry__locked_snprintf(struct hist_entry *he, char *bf,
 606                                     size_t size, unsigned int width)
 607 {
 608         const char *out;
 609         u64 mask = PERF_MEM_LOCK_NA;
 610
 611         if (he->mem_info)
 612                 mask = he->mem_info->data_src.mem_lock;
 613
 614         if (mask & PERF_MEM_LOCK_NA)
 615                 out = "N/A";
 616         else if (mask & PERF_MEM_LOCK_LOCKED)
 617                 out = "Yes";
 618         else
 619                 out = "No";
 620
 621         return repsep_snprintf(bf, size, "%-*s", width, out);
 622 }
 623
 624 static int64_t
 625 sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
 626 {
 627         union perf_mem_data_src data_src_l;
 628         union perf_mem_data_src data_src_r;
 629
 630         if (left->mem_info)
 631                 data_src_l = left->mem_info->data_src;
 632         else
 633                 data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
 634
 635         if (right->mem_info)
 636                 data_src_r = right->mem_info->data_src;
 637         else
 638                 data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
 639
 640         return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
 641 }
 642
 643 static const char * const tlb_access[] = {
 644         "N/A",
 645         "HIT",
 646         "MISS",
 647         "L1",
 648         "L2",
 649         "Walker",
 650         "Fault",
 651 };
 652 #define NUM_TLB_ACCESS (sizeof(tlb_access)/sizeof(const char *))
 653
 654 static int hist_entry__tlb_snprintf(struct hist_entry *he, char *bf,
 655                                     size_t size, unsigned int width)
 656 {
 657         char out[64];
 658         size_t sz = sizeof(out) - 1; /* -1 for null termination */
 659         size_t l = 0, i;
 660         u64 m = PERF_MEM_TLB_NA;
 661         u64 hit, miss;
 662
 663         out[0] = '\0';
 664
 665         if (he->mem_info)
 666                 m = he->mem_info->data_src.mem_dtlb;
 667
 668         hit = m & PERF_MEM_TLB_HIT;
 669         miss = m & PERF_MEM_TLB_MISS;
 670
 671         /* already taken care of */
 672         m &= ~(PERF_MEM_TLB_HIT|PERF_MEM_TLB_MISS);
 673
 674         for (i = 0; m && i < NUM_TLB_ACCESS; i++, m >>= 1) {
 675                 if (!(m & 0x1))
 676                         continue;
 677                 if (l) {
 678                         strcat(out, " or ");
 679                         l += 4;
 680                 }
 681                 strncat(out, tlb_access[i], sz - l);
 682                 l += strlen(tlb_access[i]);
 683         }
 684         if (*out == '\0')
 685                 strcpy(out, "N/A");
 686         if (hit)
 687                 strncat(out, " hit", sz - l);
 688         if (miss)
 689                 strncat(out, " miss", sz - l);
 690
 691         return repsep_snprintf(bf, size, "%-*s", width, out);
 692 }
 693
 694 static int64_t
 695 sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
 696 {
 697         union perf_mem_data_src data_src_l;
 698         union perf_mem_data_src data_src_r;
 699
 700         if (left->mem_info)
 701                 data_src_l = left->mem_info->data_src;
 702         else
 703                 data_src_l.mem_lvl = PERF_MEM_LVL_NA;
 704
 705         if (right->mem_info)
 706                 data_src_r = right->mem_info->data_src;
 707         else
 708                 data_src_r.mem_lvl = PERF_MEM_LVL_NA;
 709
 710         return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
 711 }
 712
 713 static const char * const mem_lvl[] = {
 714         "N/A",
 715         "HIT",
 716         "MISS",
 717         "L1",
 718         "LFB",
 719         "L2",
 720         "L3",
 721         "Local RAM",
 722         "Remote RAM (1 hop)",
 723         "Remote RAM (2 hops)",
 724         "Remote Cache (1 hop)",
 725         "Remote Cache (2 hops)",
 726         "I/O",
 727         "Uncached",
 728 };
 729 #define NUM_MEM_LVL (sizeof(mem_lvl)/sizeof(const char *))
 730
 731 static int hist_entry__lvl_snprintf(struct hist_entry *he, char *bf,
 732                                     size_t size, unsigned int width)
 733 {
 734         char out[64];
 735         size_t sz = sizeof(out) - 1; /* -1 for null termination */
 736         size_t i, l = 0;
 737         u64 m =  PERF_MEM_LVL_NA;
 738         u64 hit, miss;
 739
 740         if (he->mem_info)
 741                 m  = he->mem_info->data_src.mem_lvl;
 742
 743         out[0] = '\0';
 744
 745         hit = m & PERF_MEM_LVL_HIT;
 746         miss = m & PERF_MEM_LVL_MISS;
 747
 748         /* already taken care of */
 749         m &= ~(PERF_MEM_LVL_HIT|PERF_MEM_LVL_MISS);
 750
 751         for (i = 0; m && i < NUM_MEM_LVL; i++, m >>= 1) {
 752                 if (!(m & 0x1))
 753                         continue;
 754                 if (l) {
 755                         strcat(out, " or ");
 756                         l += 4;
 757                 }
 758                 strncat(out, mem_lvl[i], sz - l);
 759                 l += strlen(mem_lvl[i]);
 760         }
 761         if (*out == '\0')
 762                 strcpy(out, "N/A");
 763         if (hit)
 764                 strncat(out, " hit", sz - l);
 765         if (miss)
 766                 strncat(out, " miss", sz - l);
 767
 768         return repsep_snprintf(bf, size, "%-*s", width, out);
 769 }
 770
 771 static int64_t
 772 sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right)
 773 {
 774         union perf_mem_data_src data_src_l;
 775         union perf_mem_data_src data_src_r;
 776
 777         if (left->mem_info)
 778                 data_src_l = left->mem_info->data_src;
 779         else
 780                 data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
 781
 782         if (right->mem_info)
 783                 data_src_r = right->mem_info->data_src;
 784         else
 785                 data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
 786
 787         return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
 788 }
 789
 790 static const char * const snoop_access[] = {
 791         "N/A",
 792         "None",
 793         "Miss",
 794         "Hit",
 795         "HitM",
 796 };
 797 #define NUM_SNOOP_ACCESS (sizeof(snoop_access)/sizeof(const char *))
 798
 799 static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf,
 800                                     size_t size, unsigned int width)
 801 {
 802         char out[64];
 803         size_t sz = sizeof(out) - 1; /* -1 for null termination */
 804         size_t i, l = 0;
 805         u64 m = PERF_MEM_SNOOP_NA;
 806
 807         out[0] = '\0';
 808
 809         if (he->mem_info)
 810                 m = he->mem_info->data_src.mem_snoop;
 811
 812         for (i = 0; m && i < NUM_SNOOP_ACCESS; i++, m >>= 1) {
 813                 if (!(m & 0x1))
 814                         continue;
 815                 if (l) {
 816                         strcat(out, " or ");
 817                         l += 4;
 818                 }
 819                 strncat(out, snoop_access[i], sz - l);
 820                 l += strlen(snoop_access[i]);
 821         }
 822
 823         if (*out == '\0')
 824                 strcpy(out, "N/A");
 825
 826         return repsep_snprintf(bf, size, "%-*s", width, out);
 827 }
 828
 829 static inline  u64 cl_address(u64 address)
 830 {
 831         /* return the cacheline of the address */
 832         return (address & ~(cacheline_size - 1));
 833 }
 834
 835 static int64_t
 836 sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right)
 837 {
 838         u64 l, r;
 839         struct map *l_map, *r_map;
 840
 841         if (!left->mem_info)  return -1;
 842         if (!right->mem_info) return 1;
 843
 844         /* group event types together */
 845         if (left->cpumode > right->cpumode) return -1;
 846         if (left->cpumode < right->cpumode) return 1;
 847
 848         l_map = left->mem_info->daddr.map;
 849         r_map = right->mem_info->daddr.map;
 850
 851         /* if both are NULL, jump to sort on al_addr instead */
 852         if (!l_map && !r_map)
 853                 goto addr;
 854
 855         if (!l_map) return -1;
 856         if (!r_map) return 1;
 857
 858         if (l_map->maj > r_map->maj) return -1;
 859         if (l_map->maj < r_map->maj) return 1;
 860
 861         if (l_map->min > r_map->min) return -1;
 862         if (l_map->min < r_map->min) return 1;
 863
 864         if (l_map->ino > r_map->ino) return -1;
 865         if (l_map->ino < r_map->ino) return 1;
 866
 867         if (l_map->ino_generation > r_map->ino_generation) return -1;
 868         if (l_map->ino_generation < r_map->ino_generation) return 1;
 869
 870         /*
 871          * Addresses with no major/minor numbers are assumed to be
 872          * anonymous in userspace.  Sort those on pid then address.
 873          *
 874          * The kernel and non-zero major/minor mapped areas are
 875          * assumed to be unity mapped.  Sort those on address.
 876          */
 877
 878         if ((left->cpumode != PERF_RECORD_MISC_KERNEL) &&
 879             (!(l_map->flags & MAP_SHARED)) &&
 880             !l_map->maj && !l_map->min && !l_map->ino &&
 881             !l_map->ino_generation) {
 882                 /* userspace anonymous */
 883
 884                 if (left->thread->pid_ > right->thread->pid_) return -1;
 885                 if (left->thread->pid_ < right->thread->pid_) return 1;
 886         }
 887
 888 addr:
 889         /* al_addr does all the right addr - start + offset calculations */
 890         l = cl_address(left->mem_info->daddr.al_addr);
 891         r = cl_address(right->mem_info->daddr.al_addr);
 892
 893         if (l > r) return -1;
 894         if (l < r) return 1;
 895
 896         return 0;
 897 }
 898
 899 static int hist_entry__dcacheline_snprintf(struct hist_entry *he, char *bf,
 900                                           size_t size, unsigned int width)
 901 {
 902
 903         uint64_t addr = 0;
 904         struct map *map = NULL;
 905         struct symbol *sym = NULL;
 906         char level = he->level;
 907
 908         if (he->mem_info) {
 909                 addr = cl_address(he->mem_info->daddr.al_addr);
 910                 map = he->mem_info->daddr.map;
 911                 sym = he->mem_info->daddr.sym;
 912
 913                 /* print [s] for shared data mmaps */
 914                 if ((he->cpumode != PERF_RECORD_MISC_KERNEL) &&
 915                      map && (map->type == MAP__VARIABLE) &&
 916                     (map->flags & MAP_SHARED) &&
 917                     (map->maj || map->min || map->ino ||
 918                      map->ino_generation))
 919                         level = 's';
 920                 else if (!map)
 921                         level = 'X';
 922         }
 923         return _hist_entry__sym_snprintf(map, sym, addr, level, bf, size,
 924                                          width);
 925 }
 926
 927 struct sort_entry sort_mispredict = {
 928         .se_header      = "Branch Mispredicted",
 929         .se_cmp         = sort__mispredict_cmp,
 930         .se_snprintf    = hist_entry__mispredict_snprintf,
 931         .se_width_idx   = HISTC_MISPREDICT,
 932 };
 933
 934 static u64 he_weight(struct hist_entry *he)
 935 {
 936         return he->stat.nr_events ? he->stat.weight / he->stat.nr_events : 0;
 937 }
 938
 939 static int64_t
 940 sort__local_weight_cmp(struct hist_entry *left, struct hist_entry *right)
 941 {
 942         return he_weight(left) - he_weight(right);
 943 }
 944
 945 static int hist_entry__local_weight_snprintf(struct hist_entry *he, char *bf,
 946                                     size_t size, unsigned int width)
 947 {
 948         return repsep_snprintf(bf, size, "%-*llu", width, he_weight(he));
 949 }
 950
 951 struct sort_entry sort_local_weight = {
 952         .se_header      = "Local Weight",
 953         .se_cmp         = sort__local_weight_cmp,
 954         .se_snprintf    = hist_entry__local_weight_snprintf,
 955         .se_width_idx   = HISTC_LOCAL_WEIGHT,
 956 };
 957
 958 static int64_t
 959 sort__global_weight_cmp(struct hist_entry *left, struct hist_entry *right)
 960 {
 961         return left->stat.weight - right->stat.weight;
 962 }
 963
 964 static int hist_entry__global_weight_snprintf(struct hist_entry *he, char *bf,
 965                                               size_t size, unsigned int width)
 966 {
 967         return repsep_snprintf(bf, size, "%-*llu", width, he->stat.weight);
 968 }
 969
 970 struct sort_entry sort_global_weight = {
 971         .se_header      = "Weight",
 972         .se_cmp         = sort__global_weight_cmp,
 973         .se_snprintf    = hist_entry__global_weight_snprintf,
 974         .se_width_idx   = HISTC_GLOBAL_WEIGHT,
 975 };
 976
 977 struct sort_entry sort_mem_daddr_sym = {
 978         .se_header      = "Data Symbol",
 979         .se_cmp         = sort__daddr_cmp,
 980         .se_snprintf    = hist_entry__daddr_snprintf,
 981         .se_width_idx   = HISTC_MEM_DADDR_SYMBOL,
 982 };
 983
 984 struct sort_entry sort_mem_daddr_dso = {
 985         .se_header      = "Data Object",
 986         .se_cmp         = sort__dso_daddr_cmp,
 987         .se_snprintf    = hist_entry__dso_daddr_snprintf,
 988         .se_width_idx   = HISTC_MEM_DADDR_SYMBOL,
 989 };
 990
 991 struct sort_entry sort_mem_locked = {
 992         .se_header      = "Locked",
 993         .se_cmp         = sort__locked_cmp,
 994         .se_snprintf    = hist_entry__locked_snprintf,
 995         .se_width_idx   = HISTC_MEM_LOCKED,
 996 };
 997
 998 struct sort_entry sort_mem_tlb = {
 999         .se_header      = "TLB access",
1000         .se_cmp         = sort__tlb_cmp,
1001         .se_snprintf    = hist_entry__tlb_snprintf,
1002         .se_width_idx   = HISTC_MEM_TLB,
1003 };
1004
1005 struct sort_entry sort_mem_lvl = {
1006         .se_header      = "Memory access",
1007         .se_cmp         = sort__lvl_cmp,
1008         .se_snprintf    = hist_entry__lvl_snprintf,
1009         .se_width_idx   = HISTC_MEM_LVL,
1010 };
1011
1012 struct sort_entry sort_mem_snoop = {
1013         .se_header      = "Snoop",
1014         .se_cmp         = sort__snoop_cmp,
1015         .se_snprintf    = hist_entry__snoop_snprintf,
1016         .se_width_idx   = HISTC_MEM_SNOOP,
1017 };
1018
1019 struct sort_entry sort_mem_dcacheline = {
1020         .se_header      = "Data Cacheline",
1021         .se_cmp         = sort__dcacheline_cmp,
1022         .se_snprintf    = hist_entry__dcacheline_snprintf,
1023         .se_width_idx   = HISTC_MEM_DCACHELINE,
1024 };
1025
1026 static int64_t
1027 sort__abort_cmp(struct hist_entry *left, struct hist_entry *right)
1028 {
1029         if (!left->branch_info || !right->branch_info)
1030                 return cmp_null(left->branch_info, right->branch_info);
1031
1032         return left->branch_info->flags.abort !=
1033                 right->branch_info->flags.abort;
1034 }
1035
1036 static int hist_entry__abort_snprintf(struct hist_entry *he, char *bf,
1037                                     size_t size, unsigned int width)
1038 {
1039         static const char *out = "N/A";
1040
1041         if (he->branch_info) {
1042                 if (he->branch_info->flags.abort)
1043                         out = "A";
1044                 else
1045                         out = ".";
1046         }
1047
1048         return repsep_snprintf(bf, size, "%-*s", width, out);
1049 }
1050
1051 struct sort_entry sort_abort = {
1052         .se_header      = "Transaction abort",
1053         .se_cmp         = sort__abort_cmp,
1054         .se_snprintf    = hist_entry__abort_snprintf,
1055         .se_width_idx   = HISTC_ABORT,
1056 };
1057
1058 static int64_t
1059 sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right)
1060 {
1061         if (!left->branch_info || !right->branch_info)
1062                 return cmp_null(left->branch_info, right->branch_info);
1063
1064         return left->branch_info->flags.in_tx !=
1065                 right->branch_info->flags.in_tx;
1066 }
1067
1068 static int hist_entry__in_tx_snprintf(struct hist_entry *he, char *bf,
1069                                     size_t size, unsigned int width)
1070 {
1071         static const char *out = "N/A";
1072
1073         if (he->branch_info) {
1074                 if (he->branch_info->flags.in_tx)
1075                         out = "T";
1076                 else
1077                         out = ".";
1078         }
1079
1080         return repsep_snprintf(bf, size, "%-*s", width, out);
1081 }
1082
1083 struct sort_entry sort_in_tx = {
1084         .se_header      = "Branch in transaction",
1085         .se_cmp         = sort__in_tx_cmp,
1086         .se_snprintf    = hist_entry__in_tx_snprintf,
1087         .se_width_idx   = HISTC_IN_TX,
1088 };
1089
1090 static int64_t
1091 sort__transaction_cmp(struct hist_entry *left, struct hist_entry *right)
1092 {
1093         return left->transaction - right->transaction;
1094 }
1095
1096 static inline char *add_str(char *p, const char *str)
1097 {
1098         strcpy(p, str);
1099         return p + strlen(str);
1100 }
1101
1102 static struct txbit {
1103         unsigned flag;
1104         const char *name;
1105         int skip_for_len;
1106 } txbits[] = {
1107         { PERF_TXN_ELISION,        "EL ",        0 },
1108         { PERF_TXN_TRANSACTION,    "TX ",        1 },
1109         { PERF_TXN_SYNC,           "SYNC ",      1 },
1110         { PERF_TXN_ASYNC,          "ASYNC ",     0 },
1111         { PERF_TXN_RETRY,          "RETRY ",     0 },
1112         { PERF_TXN_CONFLICT,       "CON ",       0 },
1113         { PERF_TXN_CAPACITY_WRITE, "CAP-WRITE ", 1 },
1114         { PERF_TXN_CAPACITY_READ,  "CAP-READ ",  0 },
1115         { 0, NULL, 0 }
1116 };
1117
1118 int hist_entry__transaction_len(void)
1119 {
1120         int i;
1121         int len = 0;
1122
1123         for (i = 0; txbits[i].name; i++) {
1124                 if (!txbits[i].skip_for_len)
1125                         len += strlen(txbits[i].name);
1126         }
1127         len += 4; /* :XX<space> */
1128         return len;
1129 }
1130
1131 static int hist_entry__transaction_snprintf(struct hist_entry *he, char *bf,
1132                                             size_t size, unsigned int width)
1133 {
1134         u64 t = he->transaction;
1135         char buf[128];
1136         char *p = buf;
1137         int i;
1138
1139         buf[0] = 0;
1140         for (i = 0; txbits[i].name; i++)
1141                 if (txbits[i].flag & t)
1142                         p = add_str(p, txbits[i].name);
1143         if (t && !(t & (PERF_TXN_SYNC|PERF_TXN_ASYNC)))
1144                 p = add_str(p, "NEITHER ");
1145         if (t & PERF_TXN_ABORT_MASK) {
1146                 sprintf(p, ":%" PRIx64,
1147                         (t & PERF_TXN_ABORT_MASK) >>
1148                         PERF_TXN_ABORT_SHIFT);
1149                 p += strlen(p);
1150         }
1151
1152         return repsep_snprintf(bf, size, "%-*s", width, buf);
1153 }
1154
1155 struct sort_entry sort_transaction = {
1156         .se_header      = "Transaction                ",
1157         .se_cmp         = sort__transaction_cmp,
1158         .se_snprintf    = hist_entry__transaction_snprintf,
1159         .se_width_idx   = HISTC_TRANSACTION,
1160 };
1161
1162 struct sort_dimension {
1163         const char              *name;
1164         struct sort_entry       *entry;
1165         int                     taken;
1166 };
1167
1168 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
1169
1170 static struct sort_dimension common_sort_dimensions[] = {
1171         DIM(SORT_PID, "pid", sort_thread),
1172         DIM(SORT_COMM, "comm", sort_comm),
1173         DIM(SORT_DSO, "dso", sort_dso),
1174         DIM(SORT_SYM, "symbol", sort_sym),
1175         DIM(SORT_PARENT, "parent", sort_parent),
1176         DIM(SORT_CPU, "cpu", sort_cpu),
1177         DIM(SORT_SRCLINE, "srcline", sort_srcline),
1178         DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
1179         DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
1180         DIM(SORT_TRANSACTION, "transaction", sort_transaction),
1181 };
1182
1183 #undef DIM
1184
1185 #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
1186
1187 static struct sort_dimension bstack_sort_dimensions[] = {
1188         DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
1189         DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
1190         DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from),
1191         DIM(SORT_SYM_TO, "symbol_to", sort_sym_to),
1192         DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
1193         DIM(SORT_IN_TX, "in_tx", sort_in_tx),
1194         DIM(SORT_ABORT, "abort", sort_abort),
1195 };
1196
1197 #undef DIM
1198
1199 #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
1200
1201 static struct sort_dimension memory_sort_dimensions[] = {
1202         DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
1203         DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
1204         DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
1205         DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
1206         DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
1207         DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
1208         DIM(SORT_MEM_DCACHELINE, "dcacheline", sort_mem_dcacheline),
1209 };
1210
1211 #undef DIM
1212
1213 struct hpp_dimension {
1214         const char              *name;
1215         struct perf_hpp_fmt     *fmt;
1216         int                     taken;
1217 };
1218
1219 #define DIM(d, n) { .name = n, .fmt = &perf_hpp__format[d], }
1220
1221 static struct hpp_dimension hpp_sort_dimensions[] = {
1222         DIM(PERF_HPP__OVERHEAD, "overhead"),
1223         DIM(PERF_HPP__OVERHEAD_SYS, "overhead_sys"),
1224         DIM(PERF_HPP__OVERHEAD_US, "overhead_us"),
1225         DIM(PERF_HPP__OVERHEAD_GUEST_SYS, "overhead_guest_sys"),
1226         DIM(PERF_HPP__OVERHEAD_GUEST_US, "overhead_guest_us"),
1227         DIM(PERF_HPP__OVERHEAD_ACC, "overhead_children"),
1228         DIM(PERF_HPP__SAMPLES, "sample"),
1229         DIM(PERF_HPP__PERIOD, "period"),
1230 };
1231
1232 #undef DIM
1233
1234 struct hpp_sort_entry {
1235         struct perf_hpp_fmt hpp;
1236         struct sort_entry *se;
1237 };
1238
1239 bool perf_hpp__same_sort_entry(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
1240 {
1241         struct hpp_sort_entry *hse_a;
1242         struct hpp_sort_entry *hse_b;
1243
1244         if (!perf_hpp__is_sort_entry(a) || !perf_hpp__is_sort_entry(b))
1245                 return false;
1246
1247         hse_a = container_of(a, struct hpp_sort_entry, hpp);
1248         hse_b = container_of(b, struct hpp_sort_entry, hpp);
1249
1250         return hse_a->se == hse_b->se;
1251 }
1252
1253 void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
1254 {
1255         struct hpp_sort_entry *hse;
1256
1257         if (!perf_hpp__is_sort_entry(fmt))
1258                 return;
1259
1260         hse = container_of(fmt, struct hpp_sort_entry, hpp);
1261         hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name));
1262 }
1263
1264 static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1265                               struct perf_evsel *evsel)
1266 {
1267         struct hpp_sort_entry *hse;
1268         size_t len = fmt->user_len;
1269
1270         hse = container_of(fmt, struct hpp_sort_entry, hpp);
1271
1272         if (!len)
1273                 len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
1274
1275         return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
1276 }
1277
1278 static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
1279                              struct perf_hpp *hpp __maybe_unused,
1280                              struct perf_evsel *evsel)
1281 {
1282         struct hpp_sort_entry *hse;
1283         size_t len = fmt->user_len;
1284
1285         hse = container_of(fmt, struct hpp_sort_entry, hpp);
1286
1287         if (!len)
1288                 len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
1289
1290         return len;
1291 }
1292
1293 static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1294                              struct hist_entry *he)
1295 {
1296         struct hpp_sort_entry *hse;
1297         size_t len = fmt->user_len;
1298
1299         hse = container_of(fmt, struct hpp_sort_entry, hpp);
1300
1301         if (!len)
1302                 len = hists__col_len(he->hists, hse->se->se_width_idx);
1303
1304         return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
1305 }
1306
1307 static struct hpp_sort_entry *
1308 __sort_dimension__alloc_hpp(struct sort_dimension *sd)
1309 {
1310         struct hpp_sort_entry *hse;
1311
1312         hse = malloc(sizeof(*hse));
1313         if (hse == NULL) {
1314                 pr_err("Memory allocation failed\n");
1315                 return NULL;
1316         }
1317
1318         hse->se = sd->entry;
1319         hse->hpp.name = sd->entry->se_header;
1320         hse->hpp.header = __sort__hpp_header;
1321         hse->hpp.width = __sort__hpp_width;
1322         hse->hpp.entry = __sort__hpp_entry;
1323         hse->hpp.color = NULL;
1324
1325         hse->hpp.cmp = sd->entry->se_cmp;
1326         hse->hpp.collapse = sd->entry->se_collapse ? : sd->entry->se_cmp;
1327         hse->hpp.sort = sd->entry->se_sort ? : hse->hpp.collapse;
1328
1329         INIT_LIST_HEAD(&hse->hpp.list);
1330         INIT_LIST_HEAD(&hse->hpp.sort_list);
1331         hse->hpp.elide = false;
1332         hse->hpp.len = 0;
1333         hse->hpp.user_len = 0;
1334
1335         return hse;
1336 }
1337
1338 bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)
1339 {
1340         return format->header == __sort__hpp_header;
1341 }
1342
1343 static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd)
1344 {
1345         struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1346
1347         if (hse == NULL)
1348                 return -1;
1349
1350         perf_hpp__register_sort_field(&hse->hpp);
1351         return 0;
1352 }
1353
1354 static int __sort_dimension__add_hpp_output(struct sort_dimension *sd)
1355 {
1356         struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1357
1358         if (hse == NULL)
1359                 return -1;
1360
1361         perf_hpp__column_register(&hse->hpp);
1362         return 0;
1363 }
1364
1365 static int __sort_dimension__add(struct sort_dimension *sd)
1366 {
1367         if (sd->taken)
1368                 return 0;
1369
1370         if (__sort_dimension__add_hpp_sort(sd) < 0)
1371                 return -1;
1372
1373         if (sd->entry->se_collapse)
1374                 sort__need_collapse = 1;
1375
1376         sd->taken = 1;
1377
1378         return 0;
1379 }
1380
1381 static int __hpp_dimension__add(struct hpp_dimension *hd)
1382 {
1383         if (!hd->taken) {
1384                 hd->taken = 1;
1385
1386                 perf_hpp__register_sort_field(hd->fmt);
1387         }
1388         return 0;
1389 }
1390
1391 static int __sort_dimension__add_output(struct sort_dimension *sd)
1392 {
1393         if (sd->taken)
1394                 return 0;
1395
1396         if (__sort_dimension__add_hpp_output(sd) < 0)
1397                 return -1;
1398
1399         sd->taken = 1;
1400         return 0;
1401 }
1402
1403 static int __hpp_dimension__add_output(struct hpp_dimension *hd)
1404 {
1405         if (!hd->taken) {
1406                 hd->taken = 1;
1407
1408                 perf_hpp__column_register(hd->fmt);
1409         }
1410         return 0;
1411 }
1412
1413 int sort_dimension__add(const char *tok)
1414 {
1415         unsigned int i;
1416
1417         for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
1418                 struct sort_dimension *sd = &common_sort_dimensions[i];
1419
1420                 if (strncasecmp(tok, sd->name, strlen(tok)))
1421                         continue;
1422
1423                 if (sd->entry == &sort_parent) {
1424                         int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
1425                         if (ret) {
1426                                 char err[BUFSIZ];
1427
1428                                 regerror(ret, &parent_regex, err, sizeof(err));
1429                                 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
1430                                 return -EINVAL;
1431                         }
1432                         sort__has_parent = 1;
1433                 } else if (sd->entry == &sort_sym) {
1434                         sort__has_sym = 1;
1435                 } else if (sd->entry == &sort_dso) {
1436                         sort__has_dso = 1;
1437                 }
1438
1439                 return __sort_dimension__add(sd);
1440         }
1441
1442         for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
1443                 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
1444
1445                 if (strncasecmp(tok, hd->name, strlen(tok)))
1446                         continue;
1447
1448                 return __hpp_dimension__add(hd);
1449         }
1450
1451         for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
1452                 struct sort_dimension *sd = &bstack_sort_dimensions[i];
1453
1454                 if (strncasecmp(tok, sd->name, strlen(tok)))
1455                         continue;
1456
1457                 if (sort__mode != SORT_MODE__BRANCH)
1458                         return -EINVAL;
1459
1460                 if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
1461                         sort__has_sym = 1;
1462
1463                 __sort_dimension__add(sd);
1464                 return 0;
1465         }
1466
1467         for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
1468                 struct sort_dimension *sd = &memory_sort_dimensions[i];
1469
1470                 if (strncasecmp(tok, sd->name, strlen(tok)))
1471                         continue;
1472
1473                 if (sort__mode != SORT_MODE__MEMORY)
1474                         return -EINVAL;
1475
1476                 if (sd->entry == &sort_mem_daddr_sym)
1477                         sort__has_sym = 1;
1478
1479                 __sort_dimension__add(sd);
1480                 return 0;
1481         }
1482
1483         return -ESRCH;
1484 }
1485
1486 static const char *get_default_sort_order(void)
1487 {
1488         const char *default_sort_orders[] = {
1489                 default_sort_order,
1490                 default_branch_sort_order,
1491                 default_mem_sort_order,
1492                 default_top_sort_order,
1493                 default_diff_sort_order,
1494         };
1495
1496         BUG_ON(sort__mode >= ARRAY_SIZE(default_sort_orders));
1497
1498         return default_sort_orders[sort__mode];
1499 }
1500
1501 static int setup_sort_order(void)
1502 {
1503         char *new_sort_order;
1504
1505         /*
1506          * Append '+'-prefixed sort order to the default sort
1507          * order string.
1508          */
1509         if (!sort_order || is_strict_order(sort_order))
1510                 return 0;
1511
1512         if (sort_order[1] == '\0') {
1513                 error("Invalid --sort key: `+'");
1514                 return -EINVAL;
1515         }
1516
1517         /*
1518          * We allocate new sort_order string, but we never free it,
1519          * because it's checked over the rest of the code.
1520          */
1521         if (asprintf(&new_sort_order, "%s,%s",
1522                      get_default_sort_order(), sort_order + 1) < 0) {
1523                 error("Not enough memory to set up --sort");
1524                 return -ENOMEM;
1525         }
1526
1527         sort_order = new_sort_order;
1528         return 0;
1529 }
1530
1531 static int __setup_sorting(void)
1532 {
1533         char *tmp, *tok, *str;
1534         const char *sort_keys;
1535         int ret = 0;
1536
1537         ret = setup_sort_order();
1538         if (ret)
1539                 return ret;
1540
1541         sort_keys = sort_order;
1542         if (sort_keys == NULL) {
1543                 if (is_strict_order(field_order)) {
1544                         /*
1545                          * If user specified field order but no sort order,
1546                          * we'll honor it and not add default sort orders.
1547                          */
1548                         return 0;
1549                 }
1550
1551                 sort_keys = get_default_sort_order();
1552         }
1553
1554         str = strdup(sort_keys);
1555         if (str == NULL) {
1556                 error("Not enough memory to setup sort keys");
1557                 return -ENOMEM;
1558         }
1559
1560         for (tok = strtok_r(str, ", ", &tmp);
1561                         tok; tok = strtok_r(NULL, ", ", &tmp)) {
1562                 ret = sort_dimension__add(tok);
1563                 if (ret == -EINVAL) {
1564                         error("Invalid --sort key: `%s'", tok);
1565                         break;
1566                 } else if (ret == -ESRCH) {
1567                         error("Unknown --sort key: `%s'", tok);
1568                         break;
1569                 }
1570         }
1571
1572         free(str);
1573         return ret;
1574 }
1575
1576 void perf_hpp__set_elide(int idx, bool elide)
1577 {
1578         struct perf_hpp_fmt *fmt;
1579         struct hpp_sort_entry *hse;
1580
1581         perf_hpp__for_each_format(fmt) {
1582                 if (!perf_hpp__is_sort_entry(fmt))
1583                         continue;
1584
1585                 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1586                 if (hse->se->se_width_idx == idx) {
1587                         fmt->elide = elide;
1588                         break;
1589                 }
1590         }
1591 }
1592
1593 static bool __get_elide(struct strlist *list, const char *list_name, FILE *fp)
1594 {
1595         if (list && strlist__nr_entries(list) == 1) {
1596                 if (fp != NULL)
1597                         fprintf(fp, "# %s: %s\n", list_name,
1598                                 strlist__entry(list, 0)->s);
1599                 return true;
1600         }
1601         return false;
1602 }
1603
1604 static bool get_elide(int idx, FILE *output)
1605 {
1606         switch (idx) {
1607         case HISTC_SYMBOL:
1608                 return __get_elide(symbol_conf.sym_list, "symbol", output);
1609         case HISTC_DSO:
1610                 return __get_elide(symbol_conf.dso_list, "dso", output);
1611         case HISTC_COMM:
1612                 return __get_elide(symbol_conf.comm_list, "comm", output);
1613         default:
1614                 break;
1615         }
1616
1617         if (sort__mode != SORT_MODE__BRANCH)
1618                 return false;
1619
1620         switch (idx) {
1621         case HISTC_SYMBOL_FROM:
1622                 return __get_elide(symbol_conf.sym_from_list, "sym_from", output);
1623         case HISTC_SYMBOL_TO:
1624                 return __get_elide(symbol_conf.sym_to_list, "sym_to", output);
1625         case HISTC_DSO_FROM:
1626                 return __get_elide(symbol_conf.dso_from_list, "dso_from", output);
1627         case HISTC_DSO_TO:
1628                 return __get_elide(symbol_conf.dso_to_list, "dso_to", output);
1629         default:
1630                 break;
1631         }
1632
1633         return false;
1634 }
1635
1636 void sort__setup_elide(FILE *output)
1637 {
1638         struct perf_hpp_fmt *fmt;
1639         struct hpp_sort_entry *hse;
1640
1641         perf_hpp__for_each_format(fmt) {
1642                 if (!perf_hpp__is_sort_entry(fmt))
1643                         continue;
1644
1645                 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1646                 fmt->elide = get_elide(hse->se->se_width_idx, output);
1647         }
1648
1649         /*
1650          * It makes no sense to elide all of sort entries.
1651          * Just revert them to show up again.
1652          */
1653         perf_hpp__for_each_format(fmt) {
1654                 if (!perf_hpp__is_sort_entry(fmt))
1655                         continue;
1656
1657                 if (!fmt->elide)
1658                         return;
1659         }
1660
1661         perf_hpp__for_each_format(fmt) {
1662                 if (!perf_hpp__is_sort_entry(fmt))
1663                         continue;
1664
1665                 fmt->elide = false;
1666         }
1667 }
1668
1669 static int output_field_add(char *tok)
1670 {
1671         unsigned int i;
1672
1673         for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
1674                 struct sort_dimension *sd = &common_sort_dimensions[i];
1675
1676                 if (strncasecmp(tok, sd->name, strlen(tok)))
1677                         continue;
1678
1679                 return __sort_dimension__add_output(sd);
1680         }
1681
1682         for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
1683                 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
1684
1685                 if (strncasecmp(tok, hd->name, strlen(tok)))
1686                         continue;
1687
1688                 return __hpp_dimension__add_output(hd);
1689         }
1690
1691         for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
1692                 struct sort_dimension *sd = &bstack_sort_dimensions[i];
1693
1694                 if (strncasecmp(tok, sd->name, strlen(tok)))
1695                         continue;
1696
1697                 return __sort_dimension__add_output(sd);
1698         }
1699
1700         for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
1701                 struct sort_dimension *sd = &memory_sort_dimensions[i];
1702
1703                 if (strncasecmp(tok, sd->name, strlen(tok)))
1704                         continue;
1705
1706                 return __sort_dimension__add_output(sd);
1707         }
1708
1709         return -ESRCH;
1710 }
1711
1712 static void reset_dimensions(void)
1713 {
1714         unsigned int i;
1715
1716         for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++)
1717                 common_sort_dimensions[i].taken = 0;
1718
1719         for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++)
1720                 hpp_sort_dimensions[i].taken = 0;
1721
1722         for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++)
1723                 bstack_sort_dimensions[i].taken = 0;
1724
1725         for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++)
1726                 memory_sort_dimensions[i].taken = 0;
1727 }
1728
1729 bool is_strict_order(const char *order)
1730 {
1731         return order && (*order != '+');
1732 }
1733
1734 static int __setup_output_field(void)
1735 {
1736         char *tmp, *tok, *str, *strp;
1737         int ret = -EINVAL;
1738
1739         if (field_order == NULL)
1740                 return 0;
1741
1742         reset_dimensions();
1743
1744         strp = str = strdup(field_order);
1745         if (str == NULL) {
1746                 error("Not enough memory to setup output fields");
1747                 return -ENOMEM;
1748         }
1749
1750         if (!is_strict_order(field_order))
1751                 strp++;
1752
1753         if (!strlen(strp)) {
1754                 error("Invalid --fields key: `+'");
1755                 goto out;
1756         }
1757
1758         for (tok = strtok_r(strp, ", ", &tmp);
1759                         tok; tok = strtok_r(NULL, ", ", &tmp)) {
1760                 ret = output_field_add(tok);
1761                 if (ret == -EINVAL) {
1762                         error("Invalid --fields key: `%s'", tok);
1763                         break;
1764                 } else if (ret == -ESRCH) {
1765                         error("Unknown --fields key: `%s'", tok);
1766                         break;
1767                 }
1768         }
1769
1770 out:
1771         free(str);
1772         return ret;
1773 }
1774
1775 int setup_sorting(void)
1776 {
1777         int err;
1778
1779         err = __setup_sorting();
1780         if (err < 0)
1781                 return err;
1782
1783         if (parent_pattern != default_parent_pattern) {
1784                 err = sort_dimension__add("parent");
1785                 if (err < 0)
1786                         return err;
1787         }
1788
1789         reset_dimensions();
1790
1791         /*
1792          * perf diff doesn't use default hpp output fields.
1793          */
1794         if (sort__mode != SORT_MODE__DIFF)
1795                 perf_hpp__init();
1796
1797         err = __setup_output_field();
1798         if (err < 0)
1799                 return err;
1800
1801         /* copy sort keys to output fields */
1802         perf_hpp__setup_output_field();
1803         /* and then copy output fields to sort keys */
1804         perf_hpp__append_sort_keys();
1805
1806         return 0;
1807 }
1808
1809 void reset_output_field(void)
1810 {
1811         sort__need_collapse = 0;
1812         sort__has_parent = 0;
1813         sort__has_sym = 0;
1814         sort__has_dso = 0;
1815
1816         field_order = NULL;
1817         sort_order = NULL;
1818
1819         reset_dimensions();
1820         perf_hpp__reset_output_field();
1821 }