1/*
  2 * builtin-annotate.c
  3 *
  4 * Builtin annotate command: Analyze the perf.data input file,
  5 * look up and read DSOs and symbol information and display
  6 * a histogram of results, along various sorting keys.
  7 */
  8#include "builtin.h"
  9
 10#include "util/util.h"
 11#include "util/color.h"
 12#include <linux/list.h>
 13#include "util/cache.h"
 14#include <linux/rbtree.h>
 15#include "util/symbol.h"
 16
 17#include "perf.h"
 18#include "util/debug.h"
 19
 20#include "util/evlist.h"
 21#include "util/evsel.h"
 22#include "util/annotate.h"
 23#include "util/event.h"
 24#include "util/parse-options.h"
 25#include "util/parse-events.h"
 26#include "util/thread.h"
 27#include "util/sort.h"
 28#include "util/hist.h"
 29#include "util/session.h"
 30#include "util/tool.h"
 31#include "util/data.h"
 32#include "arch/common.h"
 33
 34#include <dlfcn.h>
 35#include <linux/bitmap.h>
 36
 37struct perf_annotate {
 38	struct perf_tool tool;
 39	bool	   force, use_tui, use_stdio, use_gtk;
 
 40	bool	   full_paths;
 41	bool	   print_line;
 42	bool	   skip_missing;
 43	const char *sym_hist_filter;
 44	const char *cpu_list;
 45	DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 46};
 47
 48static int perf_evsel__add_sample(struct perf_evsel *evsel,
 49				  struct perf_sample *sample,
 50				  struct addr_location *al,
 51				  struct perf_annotate *ann)
 52{
 
 53	struct hist_entry *he;
 54	int ret;
 55
 56	if (ann->sym_hist_filter != NULL &&
 57	    (al->sym == NULL ||
 58	     strcmp(ann->sym_hist_filter, al->sym->name) != 0)) {
 59		/* We're only interested in a symbol named sym_hist_filter */
 
 
 
 
 60		if (al->sym != NULL) {
 61			rb_erase(&al->sym->rb_node,
 62				 &al->map->dso->symbols[al->map->type]);
 63			symbol__delete(al->sym);
 
 64		}
 65		return 0;
 66	}
 67
 68	he = __hists__add_entry(&evsel->hists, al, NULL, NULL, NULL, 1, 1, 0);
 
 
 
 69	if (he == NULL)
 70		return -ENOMEM;
 71
 72	ret = hist_entry__inc_addr_samples(he, evsel->idx, al->addr);
 73	evsel->hists.stats.total_period += sample->period;
 74	hists__inc_nr_events(&evsel->hists, PERF_RECORD_SAMPLE);
 75	return ret;
 76}
 77
 78static int process_sample_event(struct perf_tool *tool,
 79				union perf_event *event,
 80				struct perf_sample *sample,
 81				struct perf_evsel *evsel,
 82				struct machine *machine)
 83{
 84	struct perf_annotate *ann = container_of(tool, struct perf_annotate, tool);
 85	struct addr_location al;
 
 86
 87	if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
 88		pr_warning("problem processing %d event, skipping it.\n",
 89			   event->header.type);
 90		return -1;
 91	}
 92
 93	if (ann->cpu_list && !test_bit(sample->cpu, ann->cpu_bitmap))
 94		return 0;
 95
 96	if (!al.filtered && perf_evsel__add_sample(evsel, sample, &al, ann)) {
 97		pr_warning("problem incrementing symbol count, "
 98			   "skipping event\n");
 99		return -1;
100	}
101
102	return 0;
 
103}
104
105static int hist_entry__tty_annotate(struct hist_entry *he,
106				    struct perf_evsel *evsel,
107				    struct perf_annotate *ann)
108{
109	return symbol__tty_annotate(he->ms.sym, he->ms.map, evsel,
110				    ann->print_line, ann->full_paths, 0, 0);
111}
112
113static void hists__find_annotations(struct hists *hists,
114				    struct perf_evsel *evsel,
115				    struct perf_annotate *ann)
116{
117	struct rb_node *nd = rb_first(&hists->entries), *next;
118	int key = K_RIGHT;
119
120	while (nd) {
121		struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
122		struct annotation *notes;
123
124		if (he->ms.sym == NULL || he->ms.map->dso->annotate_warned)
125			goto find_next;
126
127		notes = symbol__annotation(he->ms.sym);
128		if (notes->src == NULL) {
129find_next:
130			if (key == K_LEFT)
131				nd = rb_prev(nd);
132			else
133				nd = rb_next(nd);
134			continue;
135		}
136
137		if (use_browser == 2) {
138			int ret;
139			int (*annotate)(struct hist_entry *he,
140					struct perf_evsel *evsel,
141					struct hist_browser_timer *hbt);
142
143			annotate = dlsym(perf_gtk_handle,
144					 "hist_entry__gtk_annotate");
145			if (annotate == NULL) {
146				ui__error("GTK browser not found!\n");
147				return;
148			}
149
150			ret = annotate(he, evsel, NULL);
151			if (!ret || !ann->skip_missing)
152				return;
153
154			/* skip missing symbols */
155			nd = rb_next(nd);
156		} else if (use_browser == 1) {
157			key = hist_entry__tui_annotate(he, evsel, NULL);
158			switch (key) {
159			case -1:
160				if (!ann->skip_missing)
161					return;
162				/* fall through */
163			case K_RIGHT:
164				next = rb_next(nd);
165				break;
166			case K_LEFT:
167				next = rb_prev(nd);
168				break;
169			default:
170				return;
171			}
172
173			if (next != NULL)
174				nd = next;
175		} else {
176			hist_entry__tty_annotate(he, evsel, ann);
177			nd = rb_next(nd);
178			/*
179			 * Since we have a hist_entry per IP for the same
180			 * symbol, free he->ms.sym->src to signal we already
181			 * processed this symbol.
182			 */
 
183			zfree(&notes->src);
184		}
185	}
186}
187
188static int __cmd_annotate(struct perf_annotate *ann)
189{
190	int ret;
191	struct perf_session *session;
192	struct perf_evsel *pos;
193	u64 total_nr_samples;
194	struct perf_data_file file = {
195		.path  = input_name,
196		.mode  = PERF_DATA_MODE_READ,
197		.force = ann->force,
198	};
199
200	session = perf_session__new(&file, false, &ann->tool);
201	if (session == NULL)
202		return -ENOMEM;
203
204	machines__set_symbol_filter(&session->machines, symbol__annotate_init);
205
206	if (ann->cpu_list) {
207		ret = perf_session__cpu_bitmap(session, ann->cpu_list,
208					       ann->cpu_bitmap);
209		if (ret)
210			goto out_delete;
211	}
212
213	if (!objdump_path) {
214		ret = perf_session_env__lookup_objdump(&session->header.env);
215		if (ret)
216			goto out_delete;
217	}
218
219	ret = perf_session__process_events(session, &ann->tool);
220	if (ret)
221		goto out_delete;
222
223	if (dump_trace) {
224		perf_session__fprintf_nr_events(session, stdout);
225		goto out_delete;
 
226	}
227
228	if (verbose > 3)
229		perf_session__fprintf(session, stdout);
230
231	if (verbose > 2)
232		perf_session__fprintf_dsos(session, stdout);
233
234	total_nr_samples = 0;
235	evlist__for_each(session->evlist, pos) {
236		struct hists *hists = &pos->hists;
237		u32 nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
238
239		if (nr_samples > 0) {
240			total_nr_samples += nr_samples;
241			hists__collapse_resort(hists, NULL);
242			hists__output_resort(hists);
 
 
243
244			if (symbol_conf.event_group &&
245			    !perf_evsel__is_group_leader(pos))
246				continue;
247
248			hists__find_annotations(hists, pos, ann);
249		}
250	}
251
252	if (total_nr_samples == 0) {
253		ui__error("The %s file has no samples!\n", file.path);
254		goto out_delete;
255	}
256
257	if (use_browser == 2) {
258		void (*show_annotations)(void);
259
260		show_annotations = dlsym(perf_gtk_handle,
261					 "perf_gtk__show_annotations");
262		if (show_annotations == NULL) {
263			ui__error("GTK browser not found!\n");
264			goto out_delete;
265		}
266		show_annotations();
267	}
268
269out_delete:
270	/*
271	 * Speed up the exit process, for large files this can
272	 * take quite a while.
273	 *
274	 * XXX Enable this when using valgrind or if we ever
275	 * librarize this command.
276	 *
277	 * Also experiment with obstacks to see how much speed
278	 * up we'll get here.
279	 *
280	 * perf_session__delete(session);
281	 */
282	return ret;
283}
284
285static const char * const annotate_usage[] = {
286	"perf annotate [<options>]",
287	NULL
288};
289
290int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
291{
292	struct perf_annotate annotate = {
293		.tool = {
294			.sample	= process_sample_event,
295			.mmap	= perf_event__process_mmap,
296			.mmap2	= perf_event__process_mmap2,
297			.comm	= perf_event__process_comm,
298			.exit	= perf_event__process_exit,
299			.fork	= perf_event__process_fork,
300			.ordered_samples = true,
301			.ordering_requires_timestamps = true,
302		},
303	};
 
 
 
304	const struct option options[] = {
305	OPT_STRING('i', "input", &input_name, "file",
306		    "input file name"),
307	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
308		   "only consider symbols in these dsos"),
309	OPT_STRING('s', "symbol", &annotate.sym_hist_filter, "symbol",
310		    "symbol to annotate"),
311	OPT_BOOLEAN('f', "force", &annotate.force, "don't complain, do it"),
312	OPT_INCR('v', "verbose", &verbose,
313		    "be more verbose (show symbol address, etc)"),
314	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
315		    "dump raw trace in ASCII"),
316	OPT_BOOLEAN(0, "gtk", &annotate.use_gtk, "Use the GTK interface"),
317	OPT_BOOLEAN(0, "tui", &annotate.use_tui, "Use the TUI interface"),
318	OPT_BOOLEAN(0, "stdio", &annotate.use_stdio, "Use the stdio interface"),
319	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
320		   "file", "vmlinux pathname"),
321	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
322		    "load module symbols - WARNING: use only with -k and LIVE kernel"),
323	OPT_BOOLEAN('l', "print-line", &annotate.print_line,
324		    "print matching source lines (may be slow)"),
325	OPT_BOOLEAN('P', "full-paths", &annotate.full_paths,
326		    "Don't shorten the displayed pathnames"),
327	OPT_BOOLEAN(0, "skip-missing", &annotate.skip_missing,
328		    "Skip symbols that cannot be annotated"),
329	OPT_STRING('C', "cpu", &annotate.cpu_list, "cpu", "list of cpus to profile"),
330	OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
331		   "Look for files with symbols relative to this directory"),
332	OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src,
333		    "Interleave source code with assembly code (default)"),
334	OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw,
335		    "Display raw encoding of assembly instructions (default)"),
336	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
337		   "Specify disassembler style (e.g. -M intel for intel syntax)"),
338	OPT_STRING(0, "objdump", &objdump_path, "path",
339		   "objdump binary to use for disassembly and annotations"),
340	OPT_BOOLEAN(0, "group", &symbol_conf.event_group,
341		    "Show event group information together"),
 
 
342	OPT_END()
343	};
 
344
345	argc = parse_options(argc, argv, options, annotate_usage, 0);
346
347	if (annotate.use_stdio)
348		use_browser = 0;
349	else if (annotate.use_tui)
350		use_browser = 1;
351	else if (annotate.use_gtk)
352		use_browser = 2;
353
354	setup_browser(true);
355
356	symbol_conf.priv_size = sizeof(struct annotation);
357	symbol_conf.try_vmlinux_path = true;
358
359	if (symbol__init() < 0)
360		return -1;
361
362	if (setup_sorting() < 0)
363		usage_with_options(annotate_usage, options);
364
 
365	if (argc) {
366		/*
367		 * Special case: if there's an argument left then assume that
368		 * it's a symbol filter:
369		 */
370		if (argc > 1)
371			usage_with_options(annotate_usage, options);
372
373		annotate.sym_hist_filter = argv[0];
374	}
375
376	return __cmd_annotate(&annotate);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
377}

  1/*
  2 * builtin-annotate.c
  3 *
  4 * Builtin annotate command: Analyze the perf.data input file,
  5 * look up and read DSOs and symbol information and display
  6 * a histogram of results, along various sorting keys.
  7 */
  8#include "builtin.h"
  9
 10#include "util/util.h"
 11#include "util/color.h"
 12#include <linux/list.h>
 13#include "util/cache.h"
 14#include <linux/rbtree.h>
 15#include "util/symbol.h"
 16
 17#include "perf.h"
 18#include "util/debug.h"
 19
 20#include "util/evlist.h"
 21#include "util/evsel.h"
 22#include "util/annotate.h"
 23#include "util/event.h"
 24#include <subcmd/parse-options.h>
 25#include "util/parse-events.h"
 26#include "util/thread.h"
 27#include "util/sort.h"
 28#include "util/hist.h"
 29#include "util/session.h"
 30#include "util/tool.h"
 31#include "util/data.h"
 32#include "arch/common.h"
 33
 34#include <dlfcn.h>
 35#include <linux/bitmap.h>
 36
 37struct perf_annotate {
 38	struct perf_tool tool;
 39	struct perf_session *session;
 40	bool	   use_tui, use_stdio, use_gtk;
 41	bool	   full_paths;
 42	bool	   print_line;
 43	bool	   skip_missing;
 44	const char *sym_hist_filter;
 45	const char *cpu_list;
 46	DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 47};
 48
 49static int perf_evsel__add_sample(struct perf_evsel *evsel,
 50				  struct perf_sample *sample,
 51				  struct addr_location *al,
 52				  struct perf_annotate *ann)
 53{
 54	struct hists *hists = evsel__hists(evsel);
 55	struct hist_entry *he;
 56	int ret;
 57
 58	if (ann->sym_hist_filter != NULL &&
 59	    (al->sym == NULL ||
 60	     strcmp(ann->sym_hist_filter, al->sym->name) != 0)) {
 61		/* We're only interested in a symbol named sym_hist_filter */
 62		/*
 63		 * FIXME: why isn't this done in the symbol_filter when loading
 64		 * the DSO?
 65		 */
 66		if (al->sym != NULL) {
 67			rb_erase(&al->sym->rb_node,
 68				 &al->map->dso->symbols[al->map->type]);
 69			symbol__delete(al->sym);
 70			dso__reset_find_symbol_cache(al->map->dso);
 71		}
 72		return 0;
 73	}
 74
 75	sample->period = 1;
 76	sample->weight = 1;
 77
 78	he = __hists__add_entry(hists, al, NULL, NULL, NULL, sample, true);
 79	if (he == NULL)
 80		return -ENOMEM;
 81
 82	ret = hist_entry__inc_addr_samples(he, evsel->idx, al->addr);
 83	hists__inc_nr_samples(hists, true);
 
 84	return ret;
 85}
 86
 87static int process_sample_event(struct perf_tool *tool,
 88				union perf_event *event,
 89				struct perf_sample *sample,
 90				struct perf_evsel *evsel,
 91				struct machine *machine)
 92{
 93	struct perf_annotate *ann = container_of(tool, struct perf_annotate, tool);
 94	struct addr_location al;
 95	int ret = 0;
 96
 97	if (machine__resolve(machine, &al, sample) < 0) {
 98		pr_warning("problem processing %d event, skipping it.\n",
 99			   event->header.type);
100		return -1;
101	}
102
103	if (ann->cpu_list && !test_bit(sample->cpu, ann->cpu_bitmap))
104		goto out_put;
105
106	if (!al.filtered && perf_evsel__add_sample(evsel, sample, &al, ann)) {
107		pr_warning("problem incrementing symbol count, "
108			   "skipping event\n");
109		ret = -1;
110	}
111out_put:
112	addr_location__put(&al);
113	return ret;
114}
115
116static int hist_entry__tty_annotate(struct hist_entry *he,
117				    struct perf_evsel *evsel,
118				    struct perf_annotate *ann)
119{
120	return symbol__tty_annotate(he->ms.sym, he->ms.map, evsel,
121				    ann->print_line, ann->full_paths, 0, 0);
122}
123
124static void hists__find_annotations(struct hists *hists,
125				    struct perf_evsel *evsel,
126				    struct perf_annotate *ann)
127{
128	struct rb_node *nd = rb_first(&hists->entries), *next;
129	int key = K_RIGHT;
130
131	while (nd) {
132		struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
133		struct annotation *notes;
134
135		if (he->ms.sym == NULL || he->ms.map->dso->annotate_warned)
136			goto find_next;
137
138		notes = symbol__annotation(he->ms.sym);
139		if (notes->src == NULL) {
140find_next:
141			if (key == K_LEFT)
142				nd = rb_prev(nd);
143			else
144				nd = rb_next(nd);
145			continue;
146		}
147
148		if (use_browser == 2) {
149			int ret;
150			int (*annotate)(struct hist_entry *he,
151					struct perf_evsel *evsel,
152					struct hist_browser_timer *hbt);
153
154			annotate = dlsym(perf_gtk_handle,
155					 "hist_entry__gtk_annotate");
156			if (annotate == NULL) {
157				ui__error("GTK browser not found!\n");
158				return;
159			}
160
161			ret = annotate(he, evsel, NULL);
162			if (!ret || !ann->skip_missing)
163				return;
164
165			/* skip missing symbols */
166			nd = rb_next(nd);
167		} else if (use_browser == 1) {
168			key = hist_entry__tui_annotate(he, evsel, NULL);
169			switch (key) {
170			case -1:
171				if (!ann->skip_missing)
172					return;
173				/* fall through */
174			case K_RIGHT:
175				next = rb_next(nd);
176				break;
177			case K_LEFT:
178				next = rb_prev(nd);
179				break;
180			default:
181				return;
182			}
183
184			if (next != NULL)
185				nd = next;
186		} else {
187			hist_entry__tty_annotate(he, evsel, ann);
188			nd = rb_next(nd);
189			/*
190			 * Since we have a hist_entry per IP for the same
191			 * symbol, free he->ms.sym->src to signal we already
192			 * processed this symbol.
193			 */
194			zfree(&notes->src->cycles_hist);
195			zfree(&notes->src);
196		}
197	}
198}
199
200static int __cmd_annotate(struct perf_annotate *ann)
201{
202	int ret;
203	struct perf_session *session = ann->session;
204	struct perf_evsel *pos;
205	u64 total_nr_samples;
 
 
 
 
 
 
 
 
 
206
207	machines__set_symbol_filter(&session->machines, symbol__annotate_init);
208
209	if (ann->cpu_list) {
210		ret = perf_session__cpu_bitmap(session, ann->cpu_list,
211					       ann->cpu_bitmap);
212		if (ret)
213			goto out;
214	}
215
216	if (!objdump_path) {
217		ret = perf_env__lookup_objdump(&session->header.env);
218		if (ret)
219			goto out;
220	}
221
222	ret = perf_session__process_events(session);
223	if (ret)
224		goto out;
225
226	if (dump_trace) {
227		perf_session__fprintf_nr_events(session, stdout);
228		perf_evlist__fprintf_nr_events(session->evlist, stdout);
229		goto out;
230	}
231
232	if (verbose > 3)
233		perf_session__fprintf(session, stdout);
234
235	if (verbose > 2)
236		perf_session__fprintf_dsos(session, stdout);
237
238	total_nr_samples = 0;
239	evlist__for_each(session->evlist, pos) {
240		struct hists *hists = evsel__hists(pos);
241		u32 nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];
242
243		if (nr_samples > 0) {
244			total_nr_samples += nr_samples;
245			hists__collapse_resort(hists, NULL);
246			/* Don't sort callchain */
247			perf_evsel__reset_sample_bit(pos, CALLCHAIN);
248			perf_evsel__output_resort(pos, NULL);
249
250			if (symbol_conf.event_group &&
251			    !perf_evsel__is_group_leader(pos))
252				continue;
253
254			hists__find_annotations(hists, pos, ann);
255		}
256	}
257
258	if (total_nr_samples == 0) {
259		ui__error("The %s file has no samples!\n", session->file->path);
260		goto out;
261	}
262
263	if (use_browser == 2) {
264		void (*show_annotations)(void);
265
266		show_annotations = dlsym(perf_gtk_handle,
267					 "perf_gtk__show_annotations");
268		if (show_annotations == NULL) {
269			ui__error("GTK browser not found!\n");
270			goto out;
271		}
272		show_annotations();
273	}
274
275out:
 
 
 
 
 
 
 
 
 
 
 
 
276	return ret;
277}
278
279static const char * const annotate_usage[] = {
280	"perf annotate [<options>]",
281	NULL
282};
283
284int cmd_annotate(int argc, const char **argv, const char *prefix __maybe_unused)
285{
286	struct perf_annotate annotate = {
287		.tool = {
288			.sample	= process_sample_event,
289			.mmap	= perf_event__process_mmap,
290			.mmap2	= perf_event__process_mmap2,
291			.comm	= perf_event__process_comm,
292			.exit	= perf_event__process_exit,
293			.fork	= perf_event__process_fork,
294			.ordered_events = true,
295			.ordering_requires_timestamps = true,
296		},
297	};
298	struct perf_data_file file = {
299		.mode  = PERF_DATA_MODE_READ,
300	};
301	const struct option options[] = {
302	OPT_STRING('i', "input", &input_name, "file",
303		    "input file name"),
304	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
305		   "only consider symbols in these dsos"),
306	OPT_STRING('s', "symbol", &annotate.sym_hist_filter, "symbol",
307		    "symbol to annotate"),
308	OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"),
309	OPT_INCR('v', "verbose", &verbose,
310		    "be more verbose (show symbol address, etc)"),
311	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
312		    "dump raw trace in ASCII"),
313	OPT_BOOLEAN(0, "gtk", &annotate.use_gtk, "Use the GTK interface"),
314	OPT_BOOLEAN(0, "tui", &annotate.use_tui, "Use the TUI interface"),
315	OPT_BOOLEAN(0, "stdio", &annotate.use_stdio, "Use the stdio interface"),
316	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
317		   "file", "vmlinux pathname"),
318	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
319		    "load module symbols - WARNING: use only with -k and LIVE kernel"),
320	OPT_BOOLEAN('l', "print-line", &annotate.print_line,
321		    "print matching source lines (may be slow)"),
322	OPT_BOOLEAN('P', "full-paths", &annotate.full_paths,
323		    "Don't shorten the displayed pathnames"),
324	OPT_BOOLEAN(0, "skip-missing", &annotate.skip_missing,
325		    "Skip symbols that cannot be annotated"),
326	OPT_STRING('C', "cpu", &annotate.cpu_list, "cpu", "list of cpus to profile"),
327	OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
328		   "Look for files with symbols relative to this directory"),
329	OPT_BOOLEAN(0, "source", &symbol_conf.annotate_src,
330		    "Interleave source code with assembly code (default)"),
331	OPT_BOOLEAN(0, "asm-raw", &symbol_conf.annotate_asm_raw,
332		    "Display raw encoding of assembly instructions (default)"),
333	OPT_STRING('M', "disassembler-style", &disassembler_style, "disassembler style",
334		   "Specify disassembler style (e.g. -M intel for intel syntax)"),
335	OPT_STRING(0, "objdump", &objdump_path, "path",
336		   "objdump binary to use for disassembly and annotations"),
337	OPT_BOOLEAN(0, "group", &symbol_conf.event_group,
338		    "Show event group information together"),
339	OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
340		    "Show a column with the sum of periods"),
341	OPT_END()
342	};
343	int ret = hists__init();
344
345	if (ret < 0)
346		return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
347
348	argc = parse_options(argc, argv, options, annotate_usage, 0);
349	if (argc) {
350		/*
351		 * Special case: if there's an argument left then assume that
352		 * it's a symbol filter:
353		 */
354		if (argc > 1)
355			usage_with_options(annotate_usage, options);
356
357		annotate.sym_hist_filter = argv[0];
358	}
359
360	file.path  = input_name;
361
362	annotate.session = perf_session__new(&file, false, &annotate.tool);
363	if (annotate.session == NULL)
364		return -1;
365
366	symbol_conf.priv_size = sizeof(struct annotation);
367	symbol_conf.try_vmlinux_path = true;
368
369	ret = symbol__init(&annotate.session->header.env);
370	if (ret < 0)
371		goto out_delete;
372
373	if (setup_sorting(NULL) < 0)
374		usage_with_options(annotate_usage, options);
375
376	if (annotate.use_stdio)
377		use_browser = 0;
378	else if (annotate.use_tui)
379		use_browser = 1;
380	else if (annotate.use_gtk)
381		use_browser = 2;
382
383	setup_browser(true);
384
385	ret = __cmd_annotate(&annotate);
386
387out_delete:
388	/*
389	 * Speed up the exit process, for large files this can
390	 * take quite a while.
391	 *
392	 * XXX Enable this when using valgrind or if we ever
393	 * librarize this command.
394	 *
395	 * Also experiment with obstacks to see how much speed
396	 * up we'll get here.
397	 *
398	 * perf_session__delete(session);
399	 */
400	return ret;
401}