// SPDX-License-Identifier: GPL-2.0

  #include "builtin.h"

  #include "util/counts.h"

  #include "util/debug.h"

  #include "util/dso.h"

  #include <subcmd/exec-cmd.h>

  #include "util/header.h"

  #include <subcmd/parse-options.h>

  #include "util/perf_regs.h"

  #include "util/session.h"

  #include "util/tool.h"

  #include "util/map.h"

  #include "util/srcline.h"

  #include "util/symbol.h"
  #include "util/thread.h"

  #include "util/trace-event.h"

  #include "util/evlist.h"
  #include "util/evsel.h"

  #include "util/evsel_fprintf.h"

  #include "util/evswitch.h"

  #include "util/sort.h"

  #include "util/data.h"

  #include "util/auxtrace.h"

  #include "util/cpumap.h"
  #include "util/thread_map.h"
  #include "util/stat.h"

  #include "util/color.h"

  #include "util/string2.h"

  #include "util/thread-stack.h"

  #include "util/time-utils.h"

  #include "util/path.h"

  #include "ui/ui.h"

  #include "print_binary.h"

  #include "archinsn.h"

  #include <linux/bitmap.h>

  #include <linux/kernel.h>

  #include <linux/stringify.h>

  #include <linux/time64.h>

  #include <linux/zalloc.h>

  #include <sys/utsname.h>

  #include "asm/bug.h"

  #include "util/mem-events.h"

  #include "util/dump-insn.h"

  #include <dirent.h>

  #include <errno.h>

  #include <inttypes.h>

  #include <signal.h>

  #include <sys/param.h>

  #include <sys/types.h>
  #include <sys/stat.h>

  #include <fcntl.h>

  #include <unistd.h>

  #include <subcmd/pager.h>

  #include <perf/evlist.h>

  #include <linux/err.h>

  #include "util/record.h"

  #include "util/util.h"

  #include "perf.h"

  #include <linux/ctype.h>

  static char const		*script_name;
  static char const		*generate_script_lang;

  static bool			reltime;

  static bool			deltatime;

  static u64			initial_time;

  static u64			previous_time;

  static bool			debug_mode;

  static u64			last_timestamp;

  static u64			nr_unordered;

  static bool			no_callchain;

  static bool			latency_format;

  static bool			system_wide;

  static bool			print_flags;

  static const char		*cpu_list;
  static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);

  static struct perf_stat_config	stat_config;

  static int			max_blocks;

  static bool			native_arch;

  unsigned int scripting_max_stack = PERF_MAX_STACK_DEPTH;

  enum perf_output_field {

  	PERF_OUTPUT_COMM            = 1ULL << 0,
  	PERF_OUTPUT_TID             = 1ULL << 1,
  	PERF_OUTPUT_PID             = 1ULL << 2,
  	PERF_OUTPUT_TIME            = 1ULL << 3,
  	PERF_OUTPUT_CPU             = 1ULL << 4,
  	PERF_OUTPUT_EVNAME          = 1ULL << 5,
  	PERF_OUTPUT_TRACE           = 1ULL << 6,
  	PERF_OUTPUT_IP              = 1ULL << 7,
  	PERF_OUTPUT_SYM             = 1ULL << 8,
  	PERF_OUTPUT_DSO             = 1ULL << 9,
  	PERF_OUTPUT_ADDR            = 1ULL << 10,
  	PERF_OUTPUT_SYMOFFSET       = 1ULL << 11,
  	PERF_OUTPUT_SRCLINE         = 1ULL << 12,
  	PERF_OUTPUT_PERIOD          = 1ULL << 13,
  	PERF_OUTPUT_IREGS	    = 1ULL << 14,
  	PERF_OUTPUT_BRSTACK	    = 1ULL << 15,
  	PERF_OUTPUT_BRSTACKSYM	    = 1ULL << 16,
  	PERF_OUTPUT_DATA_SRC	    = 1ULL << 17,
  	PERF_OUTPUT_WEIGHT	    = 1ULL << 18,
  	PERF_OUTPUT_BPF_OUTPUT	    = 1ULL << 19,
  	PERF_OUTPUT_CALLINDENT	    = 1ULL << 20,
  	PERF_OUTPUT_INSN	    = 1ULL << 21,
  	PERF_OUTPUT_INSNLEN	    = 1ULL << 22,
  	PERF_OUTPUT_BRSTACKINSN	    = 1ULL << 23,
  	PERF_OUTPUT_BRSTACKOFF	    = 1ULL << 24,
  	PERF_OUTPUT_SYNTH           = 1ULL << 25,
  	PERF_OUTPUT_PHYS_ADDR       = 1ULL << 26,
  	PERF_OUTPUT_UREGS	    = 1ULL << 27,
  	PERF_OUTPUT_METRIC	    = 1ULL << 28,
  	PERF_OUTPUT_MISC            = 1ULL << 29,
  	PERF_OUTPUT_SRCCODE	    = 1ULL << 30,
  	PERF_OUTPUT_IPC             = 1ULL << 31,

  	PERF_OUTPUT_TOD             = 1ULL << 32,
  };
  
  struct perf_script {
  	struct perf_tool	tool;
  	struct perf_session	*session;
  	bool			show_task_events;
  	bool			show_mmap_events;
  	bool			show_switch_events;
  	bool			show_namespace_events;
  	bool			show_lost_events;
  	bool			show_round_events;
  	bool			show_bpf_events;
  	bool			show_cgroup_events;
  	bool			show_text_poke_events;
  	bool			allocated;
  	bool			per_event_dump;
  	bool			stitch_lbr;
  	struct evswitch		evswitch;
  	struct perf_cpu_map	*cpus;
  	struct perf_thread_map *threads;
  	int			name_width;
  	const char              *time_str;
  	struct perf_time_interval *ptime_range;
  	int			range_size;
  	int			range_num;

  };
  
  struct output_option {
  	const char *str;
  	enum perf_output_field field;
  } all_output_options[] = {
  	{.str = "comm",  .field = PERF_OUTPUT_COMM},
  	{.str = "tid",   .field = PERF_OUTPUT_TID},
  	{.str = "pid",   .field = PERF_OUTPUT_PID},
  	{.str = "time",  .field = PERF_OUTPUT_TIME},
  	{.str = "cpu",   .field = PERF_OUTPUT_CPU},
  	{.str = "event", .field = PERF_OUTPUT_EVNAME},
  	{.str = "trace", .field = PERF_OUTPUT_TRACE},

  	{.str = "ip",    .field = PERF_OUTPUT_IP},

  	{.str = "sym",   .field = PERF_OUTPUT_SYM},

  	{.str = "dso",   .field = PERF_OUTPUT_DSO},

  	{.str = "addr",  .field = PERF_OUTPUT_ADDR},

  	{.str = "symoff", .field = PERF_OUTPUT_SYMOFFSET},

  	{.str = "srcline", .field = PERF_OUTPUT_SRCLINE},

  	{.str = "period", .field = PERF_OUTPUT_PERIOD},

  	{.str = "iregs", .field = PERF_OUTPUT_IREGS},

  	{.str = "uregs", .field = PERF_OUTPUT_UREGS},

  	{.str = "brstack", .field = PERF_OUTPUT_BRSTACK},
  	{.str = "brstacksym", .field = PERF_OUTPUT_BRSTACKSYM},

  	{.str = "data_src", .field = PERF_OUTPUT_DATA_SRC},
  	{.str = "weight",   .field = PERF_OUTPUT_WEIGHT},

  	{.str = "bpf-output",   .field = PERF_OUTPUT_BPF_OUTPUT},

  	{.str = "callindent", .field = PERF_OUTPUT_CALLINDENT},

  	{.str = "insn", .field = PERF_OUTPUT_INSN},
  	{.str = "insnlen", .field = PERF_OUTPUT_INSNLEN},

  	{.str = "brstackinsn", .field = PERF_OUTPUT_BRSTACKINSN},

  	{.str = "brstackoff", .field = PERF_OUTPUT_BRSTACKOFF},

  	{.str = "synth", .field = PERF_OUTPUT_SYNTH},

  	{.str = "phys_addr", .field = PERF_OUTPUT_PHYS_ADDR},

  	{.str = "metric", .field = PERF_OUTPUT_METRIC},

  	{.str = "misc", .field = PERF_OUTPUT_MISC},

  	{.str = "srccode", .field = PERF_OUTPUT_SRCCODE},

  	{.str = "ipc", .field = PERF_OUTPUT_IPC},

  	{.str = "tod", .field = PERF_OUTPUT_TOD},

  };

  enum {
  	OUTPUT_TYPE_SYNTH = PERF_TYPE_MAX,
  	OUTPUT_TYPE_MAX
  };

  /* default set to maintain compatibility with current format */

  static struct {
  	bool user_set;

  	bool wildcard_set;

  	unsigned int print_ip_opts;

  	u64 fields;
  	u64 invalid_fields;

  	u64 user_set_fields;

  	u64 user_unset_fields;

  } output[OUTPUT_TYPE_MAX] = {

  
  	[PERF_TYPE_HARDWARE] = {
  		.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_SOFTWARE] = {
  		.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 |
  			      PERF_OUTPUT_BPF_OUTPUT,

  
  		.invalid_fields = PERF_OUTPUT_TRACE,
  	},
  
  	[PERF_TYPE_TRACEPOINT] = {
  		.user_set = false,
  
  		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
  				  PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |

  				  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,
  
  		.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 |
  			      PERF_OUTPUT_ADDR | PERF_OUTPUT_DATA_SRC |
  			      PERF_OUTPUT_WEIGHT | PERF_OUTPUT_PHYS_ADDR,

  		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,

  	},

  
  	[PERF_TYPE_BREAKPOINT] = {
  		.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,

  	},

  
  	[OUTPUT_TYPE_SYNTH] = {
  		.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_SYNTH,

  
  		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
  	},

  };

  struct evsel_script {

         char *filename;
         FILE *fp;
         u64  samples;

         /* For metric output */
         u64  val;
         int  gnum;

  };

  static inline struct evsel_script *evsel_script(struct evsel *evsel)

  {

  	return (struct evsel_script *)evsel->priv;

  }

  static struct evsel_script *perf_evsel_script__new(struct evsel *evsel,

  							struct perf_data *data)

  {

  	struct evsel_script *es = zalloc(sizeof(*es));

  
  	if (es != NULL) {

  		if (asprintf(&es->filename, "%s.%s.dump", data->file.path, evsel__name(evsel)) < 0)

  			goto out_free;
  		es->fp = fopen(es->filename, "w");
  		if (es->fp == NULL)
  			goto out_free_filename;

  	}
  
  	return es;
  out_free_filename:
  	zfree(&es->filename);
  out_free:
  	free(es);
  	return NULL;
  }

  static void perf_evsel_script__delete(struct evsel_script *es)

  {
  	zfree(&es->filename);
  	fclose(es->fp);
  	es->fp = NULL;
  	free(es);
  }

  static int perf_evsel_script__fprintf(struct evsel_script *es, FILE *fp)

  {
  	struct stat st;
  
  	fstat(fileno(es->fp), &st);
  	return fprintf(fp, "[ perf script: Wrote %.3f MB %s (%" PRIu64 " samples) ]
  ",
  		       st.st_size / 1024.0 / 1024.0, es->filename, es->samples);
  }

  static inline int output_type(unsigned int type)
  {
  	switch (type) {
  	case PERF_TYPE_SYNTH:
  		return OUTPUT_TYPE_SYNTH;
  	default:
  		return type;
  	}
  }
  
  static inline unsigned int attr_type(unsigned int type)
  {
  	switch (type) {
  	case OUTPUT_TYPE_SYNTH:
  		return PERF_TYPE_SYNTH;
  	default:
  		return type;
  	}
  }

  static bool output_set_by_user(void)
  {
  	int j;

  	for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {

  		if (output[j].user_set)
  			return true;
  	}
  	return false;
  }

  static const char *output_field2str(enum perf_output_field field)
  {
  	int i, imax = ARRAY_SIZE(all_output_options);
  	const char *str = "";
  
  	for (i = 0; i < imax; ++i) {
  		if (all_output_options[i].field == field) {
  			str = all_output_options[i].str;
  			break;
  		}
  	}
  	return str;
  }

  #define PRINT_FIELD(x)  (output[output_type(attr->type)].fields & PERF_OUTPUT_##x)

  static int evsel__do_check_stype(struct evsel *evsel, u64 sample_type, const char *sample_msg,
  				 enum perf_output_field field, bool allow_user_set)

  {

  	struct perf_event_attr *attr = &evsel->core.attr;

  	int type = output_type(attr->type);

  	const char *evname;
  
  	if (attr->sample_type & sample_type)
  		return 0;

  	if (output[type].user_set_fields & field) {

  		if (allow_user_set)
  			return 0;

  		evname = evsel__name(evsel);

  		pr_err("Samples for '%s' event do not have %s attribute set. "
  		       "Cannot print '%s' field.
  ",
  		       evname, sample_msg, output_field2str(field));
  		return -1;
  	}
  
  	/* user did not ask for it explicitly so remove from the default list */
  	output[type].fields &= ~field;

  	evname = evsel__name(evsel);

  	pr_debug("Samples for '%s' event do not have %s attribute set. "
  		 "Skipping '%s' field.
  ",
  		 evname, sample_msg, output_field2str(field));
  
  	return 0;
  }

  static int evsel__check_stype(struct evsel *evsel, u64 sample_type, const char *sample_msg,
  			      enum perf_output_field field)

  {

  	return evsel__do_check_stype(evsel, sample_type, sample_msg, field, false);

  }

  static int evsel__check_attr(struct evsel *evsel, struct perf_session *session)

  {

  	struct perf_event_attr *attr = &evsel->core.attr;

  	bool allow_user_set;

  	if (perf_header__has_feat(&session->header, HEADER_STAT))
  		return 0;

  	allow_user_set = perf_header__has_feat(&session->header,
  					       HEADER_AUXTRACE);

  	if (PRINT_FIELD(TRACE) &&

  	    !perf_session__has_traces(session, "record -R"))

  		return -EINVAL;

  	if (PRINT_FIELD(IP)) {

  		if (evsel__check_stype(evsel, PERF_SAMPLE_IP, "IP", PERF_OUTPUT_IP))

  			return -EINVAL;

  	}

  
  	if (PRINT_FIELD(ADDR) &&

  	    evsel__do_check_stype(evsel, PERF_SAMPLE_ADDR, "ADDR", PERF_OUTPUT_ADDR, allow_user_set))

  		return -EINVAL;

  	if (PRINT_FIELD(DATA_SRC) &&

  	    evsel__check_stype(evsel, PERF_SAMPLE_DATA_SRC, "DATA_SRC", PERF_OUTPUT_DATA_SRC))

  		return -EINVAL;
  
  	if (PRINT_FIELD(WEIGHT) &&

  	    evsel__check_stype(evsel, PERF_SAMPLE_WEIGHT, "WEIGHT", PERF_OUTPUT_WEIGHT))

  		return -EINVAL;

  	if (PRINT_FIELD(SYM) &&

  	    !(evsel->core.attr.sample_type & (PERF_SAMPLE_IP|PERF_SAMPLE_ADDR))) {

  		pr_err("Display of symbols requested but neither sample IP nor "

  			   "sample address
  available. Hence, no addresses to convert "

  		       "to symbols.
  ");

  		return -EINVAL;
  	}

  	if (PRINT_FIELD(SYMOFFSET) && !PRINT_FIELD(SYM)) {
  		pr_err("Display of offsets requested but symbol is not"
  		       "selected.
  ");
  		return -EINVAL;
  	}

  	if (PRINT_FIELD(DSO) &&

  	    !(evsel->core.attr.sample_type & (PERF_SAMPLE_IP|PERF_SAMPLE_ADDR))) {

  		pr_err("Display of DSO requested but no address to convert.
  ");

  		return -EINVAL;
  	}

  	if ((PRINT_FIELD(SRCLINE) || PRINT_FIELD(SRCCODE)) && !PRINT_FIELD(IP)) {

  		pr_err("Display of source line number requested but sample IP is not
  "
  		       "selected. Hence, no address to lookup the source line number.
  ");
  		return -EINVAL;
  	}

  	if (PRINT_FIELD(BRSTACKINSN) && !allow_user_set &&

  	    !(evlist__combined_branch_type(session->evlist) & PERF_SAMPLE_BRANCH_ANY)) {

  		pr_err("Display of branch stack assembler requested, but non all-branch filter set
  "
  		       "Hint: run 'perf record -b ...'
  ");
  		return -EINVAL;
  	}

  	if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&

  	    evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID", PERF_OUTPUT_TID|PERF_OUTPUT_PID))

  		return -EINVAL;

  
  	if (PRINT_FIELD(TIME) &&

  	    evsel__check_stype(evsel, PERF_SAMPLE_TIME, "TIME", PERF_OUTPUT_TIME))

  		return -EINVAL;

  
  	if (PRINT_FIELD(CPU) &&

  	    evsel__do_check_stype(evsel, PERF_SAMPLE_CPU, "CPU", PERF_OUTPUT_CPU, allow_user_set))

  		return -EINVAL;

  	if (PRINT_FIELD(IREGS) &&

  	    evsel__do_check_stype(evsel, PERF_SAMPLE_REGS_INTR, "IREGS", PERF_OUTPUT_IREGS, allow_user_set))

  		return -EINVAL;

  	if (PRINT_FIELD(UREGS) &&

  	    evsel__check_stype(evsel, PERF_SAMPLE_REGS_USER, "UREGS", PERF_OUTPUT_UREGS))

  		return -EINVAL;

  	if (PRINT_FIELD(PHYS_ADDR) &&

  	    evsel__check_stype(evsel, PERF_SAMPLE_PHYS_ADDR, "PHYS_ADDR", PERF_OUTPUT_PHYS_ADDR))

  		return -EINVAL;

  	return 0;
  }

  static void set_print_ip_opts(struct perf_event_attr *attr)
  {

  	unsigned int type = output_type(attr->type);

  
  	output[type].print_ip_opts = 0;
  	if (PRINT_FIELD(IP))

  		output[type].print_ip_opts |= EVSEL__PRINT_IP;

  
  	if (PRINT_FIELD(SYM))

  		output[type].print_ip_opts |= EVSEL__PRINT_SYM;

  
  	if (PRINT_FIELD(DSO))

  		output[type].print_ip_opts |= EVSEL__PRINT_DSO;

  
  	if (PRINT_FIELD(SYMOFFSET))

  		output[type].print_ip_opts |= EVSEL__PRINT_SYMOFFSET;

  
  	if (PRINT_FIELD(SRCLINE))

  		output[type].print_ip_opts |= EVSEL__PRINT_SRCLINE;

  }

  /*
   * verify all user requested events exist and the samples
   * have the expected data
   */
  static int perf_session__check_output_opt(struct perf_session *session)
  {

  	bool tod = false;

  	unsigned int j;

  	struct evsel *evsel;

  	for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
  		evsel = perf_session__find_first_evtype(session, attr_type(j));

  
  		/*
  		 * even if fields is set to 0 (ie., show nothing) event must
  		 * exist if user explicitly includes it on the command line
  		 */

  		if (!evsel && output[j].user_set && !output[j].wildcard_set &&
  		    j != OUTPUT_TYPE_SYNTH) {

  			pr_err("%s events do not exist. "

  			       "Remove corresponding -F option to proceed.
  ",

  			       event_type(j));
  			return -1;
  		}
  
  		if (evsel && output[j].fields &&

  			evsel__check_attr(evsel, session))

  			return -1;

  
  		if (evsel == NULL)
  			continue;

  		set_print_ip_opts(&evsel->core.attr);

  		tod |= output[j].fields & PERF_OUTPUT_TOD;

  	}

  	if (!no_callchain) {
  		bool use_callchain = false;

  		bool not_pipe = false;

  		evlist__for_each_entry(session->evlist, evsel) {

  			not_pipe = true;

  			if (evsel__has_callchain(evsel)) {

  				use_callchain = true;
  				break;
  			}
  		}

  		if (not_pipe && !use_callchain)

  			symbol_conf.use_callchain = false;
  	}

  	/*
  	 * set default for tracepoints to print symbols only
  	 * if callchains are present
  	 */
  	if (symbol_conf.use_callchain &&
  	    !output[PERF_TYPE_TRACEPOINT].user_set) {

  		j = PERF_TYPE_TRACEPOINT;

  		evlist__for_each_entry(session->evlist, evsel) {

  			if (evsel->core.attr.type != j)

  				continue;

  			if (evsel__has_callchain(evsel)) {

  				output[j].fields |= PERF_OUTPUT_IP;
  				output[j].fields |= PERF_OUTPUT_SYM;

  				output[j].fields |= PERF_OUTPUT_SYMOFFSET;

  				output[j].fields |= PERF_OUTPUT_DSO;

  				set_print_ip_opts(&evsel->core.attr);

  				goto out;
  			}

  		}
  	}

  	if (tod && !session->header.env.clock.enabled) {
  		pr_err("Can't provide 'tod' time, missing clock data. "
  		       "Please record with -k/--clockid option.
  ");
  		return -1;
  	}

  out:

  	return 0;
  }

  static int perf_sample__fprintf_regs(struct regs_dump *regs, uint64_t mask,

  				     FILE *fp)

  {

  	unsigned i = 0, r;

  	int printed = 0;

  
  	if (!regs || !regs->regs)

  		return 0;

  	printed += fprintf(fp, " ABI:%" PRIu64 " ", regs->abi);

  
  	for_each_set_bit(r, (unsigned long *) &mask, sizeof(mask) * 8) {
  		u64 val = regs->regs[i++];

  		printed += fprintf(fp, "%5s:0x%"PRIx64" ", perf_reg_name(r), val);

  	}

  
  	return printed;

  }

  #define DEFAULT_TOD_FMT "%F %H:%M:%S"
  
  static char*
  tod_scnprintf(struct perf_script *script, char *buf, int buflen,
  	     u64 timestamp)
  {
  	u64 tod_ns, clockid_ns;
  	struct perf_env *env;
  	unsigned long nsec;
  	struct tm ltime;
  	char date[64];
  	time_t sec;
  
  	buf[0] = '\0';
  	if (buflen < 64 || !script)
  		return buf;
  
  	env = &script->session->header.env;
  	if (!env->clock.enabled) {
  		scnprintf(buf, buflen, "disabled");
  		return buf;
  	}
  
  	clockid_ns = env->clock.clockid_ns;
  	tod_ns     = env->clock.tod_ns;
  
  	if (timestamp > clockid_ns)
  		tod_ns += timestamp - clockid_ns;
  	else
  		tod_ns -= clockid_ns - timestamp;
  
  	sec  = (time_t) (tod_ns / NSEC_PER_SEC);
  	nsec = tod_ns - sec * NSEC_PER_SEC;
  
  	if (localtime_r(&sec, &ltime) == NULL) {
  		scnprintf(buf, buflen, "failed");
  	} else {
  		strftime(date, sizeof(date), DEFAULT_TOD_FMT, &ltime);
  
  		if (symbol_conf.nanosecs) {
  			snprintf(buf, buflen, "%s.%09lu", date, nsec);
  		} else {
  			snprintf(buf, buflen, "%s.%06lu",
  				 date, nsec / NSEC_PER_USEC);
  		}
  	}
  
  	return buf;
  }

  static int perf_sample__fprintf_iregs(struct perf_sample *sample,
  				      struct perf_event_attr *attr, FILE *fp)
  {
  	return perf_sample__fprintf_regs(&sample->intr_regs,
  					 attr->sample_regs_intr, fp);
  }
  
  static int perf_sample__fprintf_uregs(struct perf_sample *sample,
  				      struct perf_event_attr *attr, FILE *fp)
  {
  	return perf_sample__fprintf_regs(&sample->user_regs,
  					 attr->sample_regs_user, fp);
  }

  static int perf_sample__fprintf_start(struct perf_script *script,
  				      struct perf_sample *sample,

  				      struct thread *thread,

  				      struct evsel *evsel,

  				      u32 type, FILE *fp)

  {

  	struct perf_event_attr *attr = &evsel->core.attr;

  	unsigned long secs;

  	unsigned long long nsecs;

  	int printed = 0;

  	char tstr[128];

  
  	if (PRINT_FIELD(COMM)) {

  		const char *comm = thread ? thread__comm_str(thread) : ":-1";

  		if (latency_format)

  			printed += fprintf(fp, "%8.8s ", comm);

  		else if (PRINT_FIELD(IP) && evsel__has_callchain(evsel) && symbol_conf.use_callchain)

  			printed += fprintf(fp, "%s ", comm);

  		else

  			printed += fprintf(fp, "%16s ", comm);

  	}

  	if (PRINT_FIELD(PID) && PRINT_FIELD(TID))

  		printed += fprintf(fp, "%5d/%-5d ", sample->pid, sample->tid);

  	else if (PRINT_FIELD(PID))

  		printed += fprintf(fp, "%5d ", sample->pid);

  	else if (PRINT_FIELD(TID))

  		printed += fprintf(fp, "%5d ", sample->tid);

  
  	if (PRINT_FIELD(CPU)) {
  		if (latency_format)

  			printed += fprintf(fp, "%3d ", sample->cpu);

  		else

  			printed += fprintf(fp, "[%03d] ", sample->cpu);

  	}

  	if (PRINT_FIELD(MISC)) {
  		int ret = 0;
  
  		#define has(m) \
  			(sample->misc & PERF_RECORD_MISC_##m) == PERF_RECORD_MISC_##m
  
  		if (has(KERNEL))
  			ret += fprintf(fp, "K");
  		if (has(USER))
  			ret += fprintf(fp, "U");
  		if (has(HYPERVISOR))
  			ret += fprintf(fp, "H");
  		if (has(GUEST_KERNEL))
  			ret += fprintf(fp, "G");
  		if (has(GUEST_USER))
  			ret += fprintf(fp, "g");
  
  		switch (type) {
  		case PERF_RECORD_MMAP:
  		case PERF_RECORD_MMAP2:
  			if (has(MMAP_DATA))
  				ret += fprintf(fp, "M");
  			break;
  		case PERF_RECORD_COMM:
  			if (has(COMM_EXEC))
  				ret += fprintf(fp, "E");
  			break;
  		case PERF_RECORD_SWITCH:
  		case PERF_RECORD_SWITCH_CPU_WIDE:

  			if (has(SWITCH_OUT)) {

  				ret += fprintf(fp, "S");

  				if (sample->misc & PERF_RECORD_MISC_SWITCH_OUT_PREEMPT)
  					ret += fprintf(fp, "p");
  			}

  		default:
  			break;
  		}
  
  		#undef has
  
  		ret += fprintf(fp, "%*s", 6 - ret, " ");
  		printed += ret;
  	}

  	if (PRINT_FIELD(TOD)) {
  		tod_scnprintf(script, tstr, sizeof(tstr), sample->time);
  		printed += fprintf(fp, "%s ", tstr);
  	}

  	if (PRINT_FIELD(TIME)) {

  		u64 t = sample->time;
  		if (reltime) {
  			if (!initial_time)
  				initial_time = sample->time;
  			t = sample->time - initial_time;

  		} else if (deltatime) {
  			if (previous_time)
  				t = sample->time - previous_time;
  			else {
  				t = 0;
  			}
  			previous_time = sample->time;

  		}
  		nsecs = t;

  		secs = nsecs / NSEC_PER_SEC;
  		nsecs -= secs * NSEC_PER_SEC;

  		if (symbol_conf.nanosecs)

  			printed += fprintf(fp, "%5lu.%09llu: ", secs, nsecs);

  		else {
  			char sample_time[32];

  			timestamp__scnprintf_usec(t, sample_time, sizeof(sample_time));

  			printed += fprintf(fp, "%12s: ", sample_time);

  		}

  	}

  
  	return printed;

  }

  static inline char
  mispred_str(struct branch_entry *br)
  {
  	if (!(br->flags.mispred  || br->flags.predicted))
  		return '-';
  
  	return br->flags.predicted ? 'P' : 'M';
  }

  static int perf_sample__fprintf_brstack(struct perf_sample *sample,
  					struct thread *thread,
  					struct perf_event_attr *attr, FILE *fp)

  {
  	struct branch_stack *br = sample->branch_stack;

  	struct branch_entry *entries = perf_sample__branch_entries(sample);

  	struct addr_location alf, alt;
  	u64 i, from, to;

  	int printed = 0;

  
  	if (!(br && br->nr))

  		return 0;

  
  	for (i = 0; i < br->nr; i++) {

  		from = entries[i].from;
  		to   = entries[i].to;

  
  		if (PRINT_FIELD(DSO)) {
  			memset(&alf, 0, sizeof(alf));
  			memset(&alt, 0, sizeof(alt));

  			thread__find_map_fb(thread, sample->cpumode, from, &alf);
  			thread__find_map_fb(thread, sample->cpumode, to, &alt);

  		}

  		printed += fprintf(fp, " 0x%"PRIx64, from);

  		if (PRINT_FIELD(DSO)) {

  			printed += fprintf(fp, "(");
  			printed += map__fprintf_dsoname(alf.map, fp);
  			printed += fprintf(fp, ")");

  		}

  		printed += fprintf(fp, "/0x%"PRIx64, to);

  		if (PRINT_FIELD(DSO)) {

  			printed += fprintf(fp, "(");
  			printed += map__fprintf_dsoname(alt.map, fp);
  			printed += fprintf(fp, ")");

  		}

  		printed += fprintf(fp, "/%c/%c/%c/%d ",

  			mispred_str(entries + i),
  			entries[i].flags.in_tx ? 'X' : '-',
  			entries[i].flags.abort ? 'A' : '-',
  			entries[i].flags.cycles);

  	}

  
  	return printed;

  }

  static int perf_sample__fprintf_brstacksym(struct perf_sample *sample,
  					   struct thread *thread,
  					   struct perf_event_attr *attr, FILE *fp)

  {
  	struct branch_stack *br = sample->branch_stack;

  	struct branch_entry *entries = perf_sample__branch_entries(sample);

  	struct addr_location alf, alt;

  	u64 i, from, to;

  	int printed = 0;

  
  	if (!(br && br->nr))

  		return 0;

  
  	for (i = 0; i < br->nr; i++) {
  
  		memset(&alf, 0, sizeof(alf));
  		memset(&alt, 0, sizeof(alt));

  		from = entries[i].from;
  		to   = entries[i].to;

  		thread__find_symbol_fb(thread, sample->cpumode, from, &alf);
  		thread__find_symbol_fb(thread, sample->cpumode, to, &alt);

  		printed += symbol__fprintf_symname_offs(alf.sym, &alf, fp);

  		if (PRINT_FIELD(DSO)) {

  			printed += fprintf(fp, "(");
  			printed += map__fprintf_dsoname(alf.map, fp);
  			printed += fprintf(fp, ")");

  		}

  		printed += fprintf(fp, "%c", '/');
  		printed += symbol__fprintf_symname_offs(alt.sym, &alt, fp);

  		if (PRINT_FIELD(DSO)) {

  			printed += fprintf(fp, "(");
  			printed += map__fprintf_dsoname(alt.map, fp);
  			printed += fprintf(fp, ")");

  		}

  		printed += fprintf(fp, "/%c/%c/%c/%d ",

  			mispred_str(entries + i),
  			entries[i].flags.in_tx ? 'X' : '-',
  			entries[i].flags.abort ? 'A' : '-',
  			entries[i].flags.cycles);

  	}

  
  	return printed;

  }

  static int perf_sample__fprintf_brstackoff(struct perf_sample *sample,
  					   struct thread *thread,
  					   struct perf_event_attr *attr, FILE *fp)

  {
  	struct branch_stack *br = sample->branch_stack;

  	struct branch_entry *entries = perf_sample__branch_entries(sample);

  	struct addr_location alf, alt;
  	u64 i, from, to;

  	int printed = 0;

  
  	if (!(br && br->nr))

  		return 0;

  
  	for (i = 0; i < br->nr; i++) {
  
  		memset(&alf, 0, sizeof(alf));
  		memset(&alt, 0, sizeof(alt));

  		from = entries[i].from;
  		to   = entries[i].to;

  		if (thread__find_map_fb(thread, sample->cpumode, from, &alf) &&

  		    !alf.map->dso->adjust_symbols)

  			from = map__map_ip(alf.map, from);

  		if (thread__find_map_fb(thread, sample->cpumode, to, &alt) &&

  		    !alt.map->dso->adjust_symbols)

  			to = map__map_ip(alt.map, to);

  		printed += fprintf(fp, " 0x%"PRIx64, from);

  		if (PRINT_FIELD(DSO)) {

  			printed += fprintf(fp, "(");
  			printed += map__fprintf_dsoname(alf.map, fp);
  			printed += fprintf(fp, ")");

  		}

  		printed += fprintf(fp, "/0x%"PRIx64, to);

  		if (PRINT_FIELD(DSO)) {

  			printed += fprintf(fp, "(");
  			printed += map__fprintf_dsoname(alt.map, fp);
  			printed += fprintf(fp, ")");

  		}

  		printed += fprintf(fp, "/%c/%c/%c/%d ",

  			mispred_str(entries + i),
  			entries[i].flags.in_tx ? 'X' : '-',
  			entries[i].flags.abort ? 'A' : '-',
  			entries[i].flags.cycles);

  	}

  
  	return printed;

  }

  #define MAXBB 16384UL
  
  static int grab_bb(u8 *buffer, u64 start, u64 end,
  		    struct machine *machine, struct thread *thread,
  		    bool *is64bit, u8 *cpumode, bool last)
  {
  	long offset, len;
  	struct addr_location al;
  	bool kernel;
  
  	if (!start || !end)
  		return 0;
  
  	kernel = machine__kernel_ip(machine, start);
  	if (kernel)
  		*cpumode = PERF_RECORD_MISC_KERNEL;
  	else
  		*cpumode = PERF_RECORD_MISC_USER;
  
  	/*
  	 * Block overlaps between kernel and user.
  	 * This can happen due to ring filtering
  	 * On Intel CPUs the entry into the kernel is filtered,
  	 * but the exit is not. Let the caller patch it up.
  	 */
  	if (kernel != machine__kernel_ip(machine, end)) {

  		pr_debug("\tblock %" PRIx64 "-%" PRIx64 " transfers between kernel and user
  ", start, end);

  		return -ENXIO;
  	}
  
  	memset(&al, 0, sizeof(al));
  	if (end - start > MAXBB - MAXINSN) {
  		if (last)

  			pr_debug("\tbrstack does not reach to final jump (%" PRIx64 "-%" PRIx64 ")
  ", start, end);

  		else

  			pr_debug("\tblock %" PRIx64 "-%" PRIx64 " (%" PRIu64 ") too long to dump
  ", start, end, end - start);

  		return 0;
  	}

  	if (!thread__find_map(thread, *cpumode, start, &al) || !al.map->dso) {

  		pr_debug("\tcannot resolve %" PRIx64 "-%" PRIx64 "
  ", start, end);

  		return 0;
  	}
  	if (al.map->dso->data.status == DSO_DATA_STATUS_ERROR) {

  		pr_debug("\tcannot resolve %" PRIx64 "-%" PRIx64 "
  ", start, end);

  		return 0;
  	}
  
  	/* Load maps to ensure dso->is_64_bit has been updated */
  	map__load(al.map);
  
  	offset = al.map->map_ip(al.map, start);
  	len = dso__data_read_offset(al.map->dso, machine, offset, (u8 *)buffer,
  				    end - start + MAXINSN);
  
  	*is64bit = al.map->dso->is_64_bit;
  	if (len <= 0)

  		pr_debug("\tcannot fetch code for block at %" PRIx64 "-%" PRIx64 "
  ",

  			start, end);
  	return len;
  }

  static int map__fprintf_srccode(struct map *map, u64 addr, FILE *fp, struct srccode_state *state)
  {
  	char *srcfile;
  	int ret = 0;
  	unsigned line;
  	int len;
  	char *srccode;
  
  	if (!map || !map->dso)
  		return 0;
  	srcfile = get_srcline_split(map->dso,
  				    map__rip_2objdump(map, addr),
  				    &line);
  	if (!srcfile)
  		return 0;
  
  	/* Avoid redundant printing */
  	if (state &&
  	    state->srcfile &&
  	    !strcmp(state->srcfile, srcfile) &&
  	    state->line == line) {
  		free(srcfile);
  		return 0;
  	}
  
  	srccode = find_sourceline(srcfile, line, &len);
  	if (!srccode)
  		goto out_free_line;
  
  	ret = fprintf(fp, "|%-8d %.*s", line, len, srccode);
  
  	if (state) {
  		state->srcfile = srcfile;
  		state->line = line;
  	}
  	return ret;
  
  out_free_line:
  	free(srcfile);
  	return ret;
  }

  static int print_srccode(struct thread *thread, u8 cpumode, uint64_t addr)
  {
  	struct addr_location al;
  	int ret = 0;
  
  	memset(&al, 0, sizeof(al));
  	thread__find_map(thread, cpumode, addr, &al);
  	if (!al.map)
  		return 0;
  	ret = map__fprintf_srccode(al.map, al.addr, stdout,
  		    &thread->srccode_state);
  	if (ret)
  		ret += printf("
  ");
  	return ret;
  }

  static int ip__fprintf_jump(uint64_t ip, struct branch_entry *en,
  			    struct perf_insn *x, u8 *inbuf, int len,

  			    int insn, FILE *fp, int *total_cycles)

  {

  	int printed = fprintf(fp, "\t%016" PRIx64 "\t%-30s\t#%s%s%s%s", ip,
  			      dump_insn(x, ip, inbuf, len, NULL),
  			      en->flags.predicted ? " PRED" : "",
  			      en->flags.mispred ? " MISPRED" : "",
  			      en->flags.in_tx ? " INTX" : "",
  			      en->flags.abort ? " ABORT" : "");

  	if (en->flags.cycles) {

  		*total_cycles += en->flags.cycles;
  		printed += fprintf(fp, " %d cycles [%d]", en->flags.cycles, *total_cycles);

  		if (insn)

  			printed += fprintf(fp, " %.2f IPC", (float)insn / en->flags.cycles);

  	}

  	return printed + fprintf(fp, "
  ");

  }

  static int ip__fprintf_sym(uint64_t addr, struct thread *thread,
  			   u8 cpumode, int cpu, struct symbol **lastsym,
  			   struct perf_event_attr *attr, FILE *fp)

  {
  	struct addr_location al;

  	int off, printed = 0;

  
  	memset(&al, 0, sizeof(al));

  	thread__find_map(thread, cpumode, addr, &al);

  	if ((*lastsym) && al.addr >= (*lastsym)->start && al.addr < (*lastsym)->end)

  		return 0;

  
  	al.cpu = cpu;
  	al.sym = NULL;
  	if (al.map)
  		al.sym = map__find_symbol(al.map, al.addr);
  
  	if (!al.sym)

  		return 0;

  
  	if (al.addr < al.sym->end)
  		off = al.addr - al.sym->start;
  	else
  		off = al.addr - al.map->start - al.sym->start;

  	printed += fprintf(fp, "\t%s", al.sym->name);

  	if (off)

  		printed += fprintf(fp, "%+d", off);
  	printed += fprintf(fp, ":");

  	if (PRINT_FIELD(SRCLINE))

  		printed += map__fprintf_srcline(al.map, al.addr, "\t", fp);
  	printed += fprintf(fp, "
  ");

  	*lastsym = al.sym;

  
  	return printed;

  }

  static int perf_sample__fprintf_brstackinsn(struct perf_sample *sample,
  					    struct thread *thread,
  					    struct perf_event_attr *attr,
  					    struct machine *machine, FILE *fp)

  {
  	struct branch_stack *br = sample->branch_stack;

  	struct branch_entry *entries = perf_sample__branch_entries(sample);

  	u64 start, end;

  	int i, insn, len, nr, ilen, printed = 0;

  	struct perf_insn x;
  	u8 buffer[MAXBB];
  	unsigned off;
  	struct symbol *lastsym = NULL;

  	int total_cycles = 0;

  
  	if (!(br && br->nr))

  		return 0;

  	nr = br->nr;
  	if (max_blocks && nr > max_blocks + 1)
  		nr = max_blocks + 1;
  
  	x.thread = thread;
  	x.cpu = sample->cpu;

  	printed += fprintf(fp, "%c", '
  ');

  
  	/* Handle first from jump, of which we don't know the entry. */

  	len = grab_bb(buffer, entries[nr-1].from,
  			entries[nr-1].from,

  			machine, thread, &x.is64bit, &x.cpumode, false);
  	if (len > 0) {

  		printed += ip__fprintf_sym(entries[nr - 1].from, thread,

  					   x.cpumode, x.cpu, &lastsym, attr, fp);

  		printed += ip__fprintf_jump(entries[nr - 1].from, &entries[nr - 1],

  					    &x, buffer, len, 0, fp, &total_cycles);

  		if (PRINT_FIELD(SRCCODE))

  			printed += print_srccode(thread, x.cpumode, entries[nr - 1].from);

  	}
  
  	/* Print all blocks */
  	for (i = nr - 2; i >= 0; i--) {

  		if (entries[i].from || entries[i].to)

  			pr_debug("%d: %" PRIx64 "-%" PRIx64 "
  ", i,

  				 entries[i].from,
  				 entries[i].to);
  		start = entries[i + 1].to;
  		end   = entries[i].from;

  
  		len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, false);
  		/* Patch up missing kernel transfers due to ring filters */
  		if (len == -ENXIO && i > 0) {

  			end = entries[--i].from;

  			pr_debug("\tpatching up to %" PRIx64 "-%" PRIx64 "
  ", start, end);
  			len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, false);
  		}
  		if (len <= 0)
  			continue;
  
  		insn = 0;

  		for (off = 0; off < (unsigned)len; off += ilen) {

  			uint64_t ip = start + off;

  			printed += ip__fprintf_sym(ip, thread, x.cpumode, x.cpu, &lastsym, attr, fp);

  			if (ip == end) {

  				printed += ip__fprintf_jump(ip, &entries[i], &x, buffer + off, len - off, ++insn, fp,

  							    &total_cycles);

  				if (PRINT_FIELD(SRCCODE))
  					printed += print_srccode(thread, x.cpumode, ip);

  				break;
  			} else {

  				ilen = 0;

  				printed += fprintf(fp, "\t%016" PRIx64 "\t%s
  ", ip,
  						   dump_insn(&x, ip, buffer + off, len - off, &ilen));

  				if (ilen == 0)
  					break;

  				if (PRINT_FIELD(SRCCODE))
  					print_srccode(thread, x.cpumode, ip);

  				insn++;
  			}
  		}

  		if (off != end - start)

  			printed += fprintf(fp, "\tmismatch of LBR data and executable
  ");

  	}
  
  	/*
  	 * Hit the branch? In this case we are already done, and the target
  	 * has not been executed yet.
  	 */

  	if (entries[0].from == sample->ip)

  		goto out;

  	if (entries[0].flags.abort)

  		goto out;

  
  	/*
  	 * Print final block upto sample

  	 *
  	 * Due to pipeline delays the LBRs might be missing a branch
  	 * or two, which can result in very large or negative blocks
  	 * between final branch and sample. When this happens just
  	 * continue walking after the last TO until we hit a branch.

  	 */

  	start = entries[0].to;

  	end = sample->ip;

  	if (end < start) {
  		/* Missing jump. Scan 128 bytes for the next branch */
  		end = start + 128;
  	}

  	len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, true);

  	printed += ip__fprintf_sym(start, thread, x.cpumode, x.cpu, &lastsym, attr, fp);

  	if (len <= 0) {
  		/* Print at least last IP if basic block did not work */
  		len = grab_bb(buffer, sample->ip, sample->ip,
  			      machine, thread, &x.is64bit, &x.cpumode, false);
  		if (len <= 0)

  			goto out;

  		printed += fprintf(fp, "\t%016" PRIx64 "\t%s
  ", sample->ip,

  			dump_insn(&x, sample->ip, buffer, len, NULL));

  		if (PRINT_FIELD(SRCCODE))
  			print_srccode(thread, x.cpumode, sample->ip);

  		goto out;

  	}
  	for (off = 0; off <= end - start; off += ilen) {

  		ilen = 0;

  		printed += fprintf(fp, "\t%016" PRIx64 "\t%s
  ", start + off,
  				   dump_insn(&x, start + off, buffer + off, len - off, &ilen));

  		if (ilen == 0)
  			break;

  		if (arch_is_branch(buffer + off, len - off, x.is64bit) && start + off != sample->ip) {
  			/*
  			 * Hit a missing branch. Just stop.
  			 */
  			printed += fprintf(fp, "\t... not reaching sample ...
  ");
  			break;
  		}

  		if (PRINT_FIELD(SRCCODE))
  			print_srccode(thread, x.cpumode, start + off);

  	}

  out:
  	return printed;

  }

  static int perf_sample__fprintf_addr(struct perf_sample *sample,
  				     struct thread *thread,
  				     struct perf_event_attr *attr, FILE *fp)

  {
  	struct addr_location al;

  	int printed = fprintf(fp, "%16" PRIx64, sample->addr);

  
  	if (!sample_addr_correlates_sym(attr))

  		goto out;

  	thread__resolve(thread, &al, sample);

  
  	if (PRINT_FIELD(SYM)) {

  		printed += fprintf(fp, " ");

  		if (PRINT_FIELD(SYMOFFSET))

  			printed += symbol__fprintf_symname_offs(al.sym, &al, fp);

  		else

  			printed += symbol__fprintf_symname(al.sym, fp);

  	}
  
  	if (PRINT_FIELD(DSO)) {

  		printed += fprintf(fp, " (");
  		printed += map__fprintf_dsoname(al.map, fp);
  		printed += fprintf(fp, ")");

  	}

  out:
  	return printed;

  }

  static const char *resolve_branch_sym(struct perf_sample *sample,

  				      struct evsel *evsel,

  				      struct thread *thread,
  				      struct addr_location *al,
  				      u64 *ip)
  {
  	struct addr_location addr_al;

  	struct perf_event_attr *attr = &evsel->core.attr;

  	const char *name = NULL;
  
  	if (sample->flags & (PERF_IP_FLAG_CALL | PERF_IP_FLAG_TRACE_BEGIN)) {
  		if (sample_addr_correlates_sym(attr)) {
  			thread__resolve(thread, &addr_al, sample);
  			if (addr_al.sym)
  				name = addr_al.sym->name;
  			else
  				*ip = sample->addr;
  		} else {
  			*ip = sample->addr;
  		}
  	} else if (sample->flags & (PERF_IP_FLAG_RETURN | PERF_IP_FLAG_TRACE_END)) {
  		if (al->sym)
  			name = al->sym->name;
  		else
  			*ip = sample->ip;
  	}
  	return name;
  }

  static int perf_sample__fprintf_callindent(struct perf_sample *sample,

  					   struct evsel *evsel,

  					   struct thread *thread,
  					   struct addr_location *al, FILE *fp)

  {

  	struct perf_event_attr *attr = &evsel->core.attr;

  	size_t depth = thread_stack__depth(thread, sample->cpu);

  	const char *name = NULL;
  	static int spacing;
  	int len = 0;

  	int dlen = 0;

  	u64 ip = 0;
  
  	/*
  	 * The 'return' has already been popped off the stack so the depth has
  	 * to be adjusted to match the 'call'.
  	 */
  	if (thread->ts && sample->flags & PERF_IP_FLAG_RETURN)
  		depth += 1;

  	name = resolve_branch_sym(sample, evsel, thread, al, &ip);

  	if (PRINT_FIELD(DSO) && !(PRINT_FIELD(IP) || PRINT_FIELD(ADDR))) {
  		dlen += fprintf(fp, "(");
  		dlen += map__fprintf_dsoname(al->map, fp);
  		dlen += fprintf(fp, ")\t");
  	}

  	if (name)

  		len = fprintf(fp, "%*s%s", (int)depth * 4, "", name);

  	else if (ip)

  		len = fprintf(fp, "%*s%16" PRIx64, (int)depth * 4, "", ip);

  
  	if (len < 0)

  		return len;

  
  	/*
  	 * Try to keep the output length from changing frequently so that the
  	 * output lines up more nicely.
  	 */
  	if (len > spacing || (len && len < spacing - 52))
  		spacing = round_up(len + 4, 32);
  
  	if (len < spacing)

  		len += fprintf(fp, "%*s", spacing - len, "");

  	return len + dlen;

  }

  __weak void arch_fetch_insn(struct perf_sample *sample __maybe_unused,
  			    struct thread *thread __maybe_unused,
  			    struct machine *machine __maybe_unused)
  {
  }

  static int perf_sample__fprintf_insn(struct perf_sample *sample,
  				     struct perf_event_attr *attr,
  				     struct thread *thread,
  				     struct machine *machine, FILE *fp)

  {

  	int printed = 0;

  	if (sample->insn_len == 0 && native_arch)
  		arch_fetch_insn(sample, thread, machine);

  	if (PRINT_FIELD(INSNLEN))

  		printed += fprintf(fp, " ilen: %d", sample->insn_len);

  	if (PRINT_FIELD(INSN) && sample->insn_len) {

  		int i;

  		printed += fprintf(fp, " insn:");

  		for (i = 0; i < sample->insn_len; i++)

  			printed += fprintf(fp, " %02x", (unsigned char)sample->insn[i]);

  	}

  	if (PRINT_FIELD(BRSTACKINSN))

  		printed += perf_sample__fprintf_brstackinsn(sample, thread, attr, machine, fp);
  
  	return printed;

  }

  static int perf_sample__fprintf_ipc(struct perf_sample *sample,
  				    struct perf_event_attr *attr, FILE *fp)
  {
  	unsigned int ipc;
  
  	if (!PRINT_FIELD(IPC) || !sample->cyc_cnt || !sample->insn_cnt)
  		return 0;
  
  	ipc = (sample->insn_cnt * 100) / sample->cyc_cnt;
  
  	return fprintf(fp, " \t IPC: %u.%02u (%" PRIu64 "/%" PRIu64 ") ",
  		       ipc / 100, ipc % 100, sample->insn_cnt, sample->cyc_cnt);
  }

  static int perf_sample__fprintf_bts(struct perf_sample *sample,

  				    struct evsel *evsel,

  				    struct thread *thread,
  				    struct addr_location *al,
  				    struct machine *machine, FILE *fp)

  {

  	struct perf_event_attr *attr = &evsel->core.attr;

  	unsigned int type = output_type(attr->type);

  	bool print_srcline_last = false;

  	int printed = 0;

  	if (PRINT_FIELD(CALLINDENT))

  		printed += perf_sample__fprintf_callindent(sample, evsel, thread, al, fp);

  	/* print branch_from information */
  	if (PRINT_FIELD(IP)) {

  		unsigned int print_opts = output[type].print_ip_opts;

  		struct callchain_cursor *cursor = NULL;

  		if (symbol_conf.use_callchain && sample->callchain &&

  		    thread__resolve_callchain(al->thread, &callchain_cursor, evsel,

  					      sample, NULL, NULL, scripting_max_stack) == 0)

  			cursor = &callchain_cursor;

  
  		if (cursor == NULL) {

  			printed += fprintf(fp, " ");

  			if (print_opts & EVSEL__PRINT_SRCLINE) {

  				print_srcline_last = true;

  				print_opts &= ~EVSEL__PRINT_SRCLINE;

  			}

  		} else

  			printed += fprintf(fp, "
  ");

  		printed += sample__fprintf_sym(sample, al, 0, print_opts, cursor,
  					       symbol_conf.bt_stop_list, fp);

  	}

  	/* print branch_to information */

  	if (PRINT_FIELD(ADDR) ||

  	    ((evsel->core.attr.sample_type & PERF_SAMPLE_ADDR) &&

  	     !output[type].user_set)) {

  		printed += fprintf(fp, " => ");
  		printed += perf_sample__fprintf_addr(sample, thread, attr, fp);

  	}