static int64_t
sort__sym_sort(struct hist_entry *left, struct hist_entry *right)
{
if (!left->ms.sym || !right->ms.sym)
return cmp_null(left->ms.sym, right->ms.sym);
return strcmp(right->ms.sym->name, left->ms.sym->name);
}
static int64_t
sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
{
if (!left->branch_info || !right->branch_info)
return cmp_null(left->branch_info, right->branch_info);
return _sort__dso_cmp(left->branch_info->to.map,
right->branch_info->to.map);
}
static int64_t
sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right)
{
if (!left->branch_info || !right->branch_info)
return cmp_null(left->branch_info, right->branch_info);
return left->branch_info->flags.in_tx !=
right->branch_info->flags.in_tx;
}
static int64_t
sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
{
char *comm_l = left->thread->comm;
char *comm_r = right->thread->comm;
if (!comm_l || !comm_r)
return cmp_null(comm_l, comm_r);
return strcmp(comm_l, comm_r);
}
static int64_t
sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
{
struct symbol *sym_l = left->parent;
struct symbol *sym_r = right->parent;
if (!sym_l || !sym_r)
return cmp_null(sym_l, sym_r);
return strcmp(sym_l->name, sym_r->name);
}
static int64_t
sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
{
unsigned char mp, p;
if (!left->branch_info || !right->branch_info)
return cmp_null(left->branch_info, right->branch_info);
mp = left->branch_info->flags.mispred != right->branch_info->flags.mispred;
p = left->branch_info->flags.predicted != right->branch_info->flags.predicted;
return mp || p;
}
static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
{
if (!sym_l || !sym_r)
return cmp_null(sym_l, sym_r);
if (sym_l == sym_r)
return 0;
if (sym_l->start != sym_r->start)
return (int64_t)(sym_r->start - sym_l->start);
return (int64_t)(sym_r->end - sym_l->end);
}
static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
{
u64 ip_l, ip_r;
if (!sym_l || !sym_r)
return cmp_null(sym_l, sym_r);
if (sym_l == sym_r)
return 0;
ip_l = sym_l->start;
ip_r = sym_r->start;
return (int64_t)(ip_r - ip_l);
}
static int64_t
sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
{
struct addr_map_symbol *to_l, *to_r;
if (!left->branch_info || !right->branch_info)
return cmp_null(left->branch_info, right->branch_info);
to_l = &left->branch_info->to;
to_r = &right->branch_info->to;
if (!to_l->sym && !to_r->sym)
return _sort__addr_cmp(to_l->addr, to_r->addr);
return _sort__sym_cmp(to_l->sym, to_r->sym);
}
static int64_t
sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
{
struct addr_map_symbol *from_l = &left->branch_info->from;
struct addr_map_symbol *from_r = &right->branch_info->from;
if (!left->branch_info || !right->branch_info)
return cmp_null(left->branch_info, right->branch_info);
from_l = &left->branch_info->from;
from_r = &right->branch_info->from;
if (!from_l->sym && !from_r->sym)
return _sort__addr_cmp(from_l->addr, from_r->addr);
return _sort__sym_cmp(from_l->sym, from_r->sym);
}
static int64_t
sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
{
u64 ip_l, ip_r;
if (!left->ms.sym && !right->ms.sym)
return right->level - left->level;
if (!left->ms.sym || !right->ms.sym)
return cmp_null(left->ms.sym, right->ms.sym);
if (left->ms.sym == right->ms.sym)
return 0;
ip_l = left->ms.sym->start;
ip_r = right->ms.sym->start;
return _sort__sym_cmp(left->ms.sym, right->ms.sym, ip_l, ip_r);
}
static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
{
struct dso *dso_l = map_l ? map_l->dso : NULL;
struct dso *dso_r = map_r ? map_r->dso : NULL;
const char *dso_name_l, *dso_name_r;
if (!dso_l || !dso_r)
return cmp_null(dso_l, dso_r);
if (verbose) {
dso_name_l = dso_l->long_name;
dso_name_r = dso_r->long_name;
} else {
dso_name_l = dso_l->short_name;
dso_name_r = dso_r->short_name;
}
return strcmp(dso_name_l, dso_name_r);
}
SInt64 JSON::comparef(const JSON& a, const JSON& b)
{
switch (a.m_type)
{
case e_null:
switch (b.m_type)
{
case e_null: return cmp_null(a,b);
case e_bool: return cmp_bool(a,b);
case e_integer: return cmp_integer(a,b);
case e_real: return cmp_real(a,b);
case e_string: return cmp_string(a,b);
case e_array: return cmp_array(a,b);
case e_object: return cmp_object(a,b);
}
case e_bool:
switch (b.m_type)
{
case e_null: return cmp_bool(a,b);
case e_bool: return cmp_bool(a,b);
case e_integer: return cmp_integer(a,b);
case e_real: return cmp_real(a,b);
case e_string: return cmp_string(a,b);
case e_array: return cmp_array(a,b);
case e_object: return cmp_object(a,b);
}
case e_integer:
switch (b.m_type)
{
case e_null: return cmp_integer(a,b);
case e_bool: return cmp_integer(a,b);
case e_integer: return cmp_integer(a,b);
case e_real: return cmp_real(a,b);
case e_string: return cmp_string(a,b);
case e_array: return cmp_array(a,b);
case e_object: return cmp_object(a,b);
}
case e_real:
switch (b.m_type)
{
case e_null: return cmp_real(a,b);
case e_bool: return cmp_real(a,b);
case e_integer: return cmp_real(a,b);
case e_real: return cmp_real(a,b);
case e_string: return cmp_string(a,b);
case e_array: return cmp_array(a,b);
case e_object: return cmp_object(a,b);
}
case e_string:
switch (b.m_type)
{
case e_null: return cmp_string(a,b);
case e_bool: return cmp_string(a,b);
case e_integer: return cmp_string(a,b);
case e_real: return cmp_string(a,b);
case e_string: return cmp_string(a,b);
case e_array: return cmp_array(a,b);
case e_object: return cmp_object(a,b);
}
case e_array:
switch (b.m_type)
{
case e_null: return cmp_array(a,b);
case e_bool: return cmp_array(a,b);
case e_integer: return cmp_array(a,b);
case e_real: return cmp_array(a,b);
case e_string: return cmp_array(a,b);
case e_array: return cmp_array(a,b);
case e_object: return cmp_object(a,b);
}
case e_object:
switch (b.m_type)
{
case e_null: return cmp_object(a,b);
case e_bool: return cmp_object(a,b);
case e_integer: return cmp_object(a,b);
case e_real: return cmp_object(a,b);
case e_string: return cmp_object(a,b);
case e_array: return cmp_object(a,b);
case e_object: return cmp_object(a,b);
}
}
Check();
return -1;
}
