Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
perf annotate: Use global annotation_options
Now it can directly use the global options and no need to pass it as an
argument.
Reviewed-by: Ian Rogers <irogers@google.com>
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: https://lore.kernel.org/r/20231128175441.721579-5-namhyung@kernel.org
[ Fixup build with GTK2=1 ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
authored by
Namhyung Kim
and committed by
Arnaldo Carvalho de Melo
41fd3cac
c9a21a87
+71
-89
+3
-4
tools/perf/builtin-annotate.c
+3
-4
tools/perf/builtin-annotate.c
···
317
317
struct perf_annotate *ann)
318
318
{
319
319
if (!ann->use_stdio2)
320
-
return symbol__tty_annotate(&he->ms, evsel, &annotate_opts);
320
+
return symbol__tty_annotate(&he->ms, evsel);
321
321
322
-
return symbol__tty_annotate2(&he->ms, evsel, &annotate_opts);
322
+
return symbol__tty_annotate2(&he->ms, evsel);
323
323
}
324
324
325
325
static void hists__find_annotations(struct hists *hists,
···
365
365
int ret;
366
366
int (*annotate)(struct hist_entry *he,
367
367
struct evsel *evsel,
368
-
struct annotation_options *options,
369
368
struct hist_browser_timer *hbt);
370
369
371
370
annotate = dlsym(perf_gtk_handle,
···
374
375
return;
375
376
}
376
377
377
-
ret = annotate(he, evsel, &annotate_opts, NULL);
378
+
ret = annotate(he, evsel, NULL);
378
379
if (!ret || !ann->skip_missing)
379
380
return;
380
381
+1
-1
tools/perf/builtin-report.c
+1
-1
tools/perf/builtin-report.c
+2
-2
tools/perf/builtin-top.c
+2
-2
tools/perf/builtin-top.c
···
147
147
return err;
148
148
}
149
149
150
-
err = symbol__annotate(&he->ms, evsel, &annotate_opts, NULL);
150
+
err = symbol__annotate(&he->ms, evsel, NULL);
151
151
if (err == 0) {
152
152
top->sym_filter_entry = he;
153
153
} else {
···
263
263
printf("Showing %s for %s\n", evsel__name(top->sym_evsel), symbol->name);
264
264
printf(" Events Pcnt (>=%d%%)\n", annotate_opts.min_pcnt);
265
265
266
-
more = symbol__annotate_printf(&he->ms, top->sym_evsel, &annotate_opts);
266
+
more = symbol__annotate_printf(&he->ms, top->sym_evsel);
267
267
268
268
if (top->evlist->enabled) {
269
269
if (top->zero)
+3
-3
tools/perf/ui/browsers/annotate.c
+3
-3
tools/perf/ui/browsers/annotate.c
···
114
114
if (!browser->navkeypressed)
115
115
ops.width += 1;
116
116
117
-
annotation_line__write(al, notes, &ops, ab->opts);
117
+
annotation_line__write(al, notes, &ops);
118
118
119
119
if (ops.current_entry)
120
120
ab->selection = al;
···
884
884
continue;
885
885
}
886
886
case 'P':
887
-
map_symbol__annotation_dump(ms, evsel, browser->opts);
887
+
map_symbol__annotation_dump(ms, evsel);
888
888
continue;
889
889
case 't':
890
890
if (symbol_conf.show_total_period) {
···
979
979
return -1;
980
980
981
981
if (not_annotated) {
982
-
err = symbol__annotate2(ms, evsel, opts, &browser.arch);
982
+
err = symbol__annotate2(ms, evsel, &browser.arch);
983
983
if (err) {
984
984
char msg[BUFSIZ];
985
985
dso->annotate_warned = true;
+2
-4
tools/perf/ui/gtk/annotate.c
+2
-4
tools/perf/ui/gtk/annotate.c
···
162
162
}
163
163
164
164
static int symbol__gtk_annotate(struct map_symbol *ms, struct evsel *evsel,
165
-
struct annotation_options *options,
166
165
struct hist_browser_timer *hbt)
167
166
{
168
167
struct dso *dso = map__dso(ms->map);
···
175
176
if (dso->annotate_warned)
176
177
return -1;
177
178
178
-
err = symbol__annotate(ms, evsel, options, NULL);
179
+
err = symbol__annotate(ms, evsel, NULL);
179
180
if (err) {
180
181
char msg[BUFSIZ];
181
182
dso->annotate_warned = true;
···
243
244
244
245
int hist_entry__gtk_annotate(struct hist_entry *he,
245
246
struct evsel *evsel,
246
-
struct annotation_options *options,
247
247
struct hist_browser_timer *hbt)
248
248
{
249
-
return symbol__gtk_annotate(&he->ms, evsel, options, hbt);
249
+
return symbol__gtk_annotate(&he->ms, evsel, hbt);
250
250
}
251
251
252
252
void perf_gtk__show_annotations(void)
-2
tools/perf/ui/gtk/gtk.h
-2
tools/perf/ui/gtk/gtk.h
···
56
56
struct evlist;
57
57
struct hist_entry;
58
58
struct hist_browser_timer;
59
-
struct annotation_options;
60
59
61
60
int evlist__gtk_browse_hists(struct evlist *evlist, const char *help,
62
61
struct hist_browser_timer *hbt, float min_pcnt);
63
62
int hist_entry__gtk_annotate(struct hist_entry *he,
64
63
struct evsel *evsel,
65
-
struct annotation_options *options,
66
64
struct hist_browser_timer *hbt);
67
65
void perf_gtk__show_annotations(void);
68
66
+55
-63
tools/perf/util/annotate.c
+55
-63
tools/perf/util/annotate.c
···
1896
1896
struct annotate_args *args)
1897
1897
{
1898
1898
struct annotation *notes = symbol__annotation(sym);
1899
-
struct annotation_options *opts = args->options;
1900
1899
struct bpf_prog_linfo *prog_linfo = NULL;
1901
1900
struct bpf_prog_info_node *info_node;
1902
1901
int len = sym->end - sym->start;
···
2005
2006
prev_buf_size = buf_size;
2006
2007
fflush(s);
2007
2008
2008
-
if (!opts->hide_src_code && srcline) {
2009
+
if (!annotate_opts.hide_src_code && srcline) {
2009
2010
args->offset = -1;
2010
2011
args->line = strdup(srcline);
2011
2012
args->line_nr = 0;
···
2128
2129
2129
2130
static int symbol__disassemble(struct symbol *sym, struct annotate_args *args)
2130
2131
{
2131
-
struct annotation_options *opts = args->options;
2132
+
struct annotation_options *opts = &annotate_opts;
2132
2133
struct map *map = args->ms.map;
2133
2134
struct dso *dso = map__dso(map);
2134
2135
char *command;
···
2379
2380
}
2380
2381
2381
2382
int symbol__annotate(struct map_symbol *ms, struct evsel *evsel,
2382
-
struct annotation_options *options, struct arch **parch)
2383
+
struct arch **parch)
2383
2384
{
2384
2385
struct symbol *sym = ms->sym;
2385
2386
struct annotation *notes = symbol__annotation(sym);
2386
2387
struct annotate_args args = {
2387
2388
.evsel = evsel,
2388
-
.options = options,
2389
+
.options = &annotate_opts,
2389
2390
};
2390
2391
struct perf_env *env = evsel__env(evsel);
2391
2392
const char *arch_name = perf_env__arch(env);
···
2413
2414
}
2414
2415
2415
2416
args.ms = *ms;
2416
-
if (notes->options && notes->options->full_addr)
2417
+
if (annotate_opts.full_addr)
2417
2418
notes->start = map__objdump_2mem(ms->map, ms->sym->start);
2418
2419
else
2419
2420
notes->start = map__rip_2objdump(ms->map, ms->sym->start);
···
2421
2422
return symbol__disassemble(sym, &args);
2422
2423
}
2423
2424
2424
-
static void insert_source_line(struct rb_root *root, struct annotation_line *al,
2425
-
struct annotation_options *opts)
2425
+
static void insert_source_line(struct rb_root *root, struct annotation_line *al)
2426
2426
{
2427
2427
struct annotation_line *iter;
2428
2428
struct rb_node **p = &root->rb_node;
2429
2429
struct rb_node *parent = NULL;
2430
+
unsigned int percent_type = annotate_opts.percent_type;
2430
2431
int i, ret;
2431
2432
2432
2433
while (*p != NULL) {
···
2437
2438
if (ret == 0) {
2438
2439
for (i = 0; i < al->data_nr; i++) {
2439
2440
iter->data[i].percent_sum += annotation_data__percent(&al->data[i],
2440
-
opts->percent_type);
2441
+
percent_type);
2441
2442
}
2442
2443
return;
2443
2444
}
···
2450
2451
2451
2452
for (i = 0; i < al->data_nr; i++) {
2452
2453
al->data[i].percent_sum = annotation_data__percent(&al->data[i],
2453
-
opts->percent_type);
2454
+
percent_type);
2454
2455
}
2455
2456
2456
2457
rb_link_node(&al->rb_node, parent, p);
···
2572
2573
return 0;
2573
2574
}
2574
2575
2575
-
int symbol__annotate_printf(struct map_symbol *ms, struct evsel *evsel,
2576
-
struct annotation_options *opts)
2576
+
int symbol__annotate_printf(struct map_symbol *ms, struct evsel *evsel)
2577
2577
{
2578
2578
struct map *map = ms->map;
2579
2579
struct symbol *sym = ms->sym;
···
2583
2585
struct annotation *notes = symbol__annotation(sym);
2584
2586
struct sym_hist *h = annotation__histogram(notes, evsel->core.idx);
2585
2587
struct annotation_line *pos, *queue = NULL;
2588
+
struct annotation_options *opts = &annotate_opts;
2586
2589
u64 start = map__rip_2objdump(map, sym->start);
2587
2590
int printed = 2, queue_len = 0, addr_fmt_width;
2588
2591
int more = 0;
···
2712
2713
fputs(s, fp);
2713
2714
}
2714
2715
2715
-
static int symbol__annotate_fprintf2(struct symbol *sym, FILE *fp,
2716
-
struct annotation_options *opts)
2716
+
static int symbol__annotate_fprintf2(struct symbol *sym, FILE *fp)
2717
2717
{
2718
2718
struct annotation *notes = symbol__annotation(sym);
2719
2719
struct annotation_write_ops wops = {
···
2729
2731
list_for_each_entry(al, ¬es->src->source, node) {
2730
2732
if (annotation_line__filter(al, notes))
2731
2733
continue;
2732
-
annotation_line__write(al, notes, &wops, opts);
2734
+
annotation_line__write(al, notes, &wops);
2733
2735
fputc('\n', fp);
2734
2736
wops.first_line = false;
2735
2737
}
···
2737
2739
return 0;
2738
2740
}
2739
2741
2740
-
int map_symbol__annotation_dump(struct map_symbol *ms, struct evsel *evsel,
2741
-
struct annotation_options *opts)
2742
+
int map_symbol__annotation_dump(struct map_symbol *ms, struct evsel *evsel)
2742
2743
{
2743
2744
const char *ev_name = evsel__name(evsel);
2744
2745
char buf[1024];
···
2759
2762
2760
2763
fprintf(fp, "%s() %s\nEvent: %s\n\n",
2761
2764
ms->sym->name, map__dso(ms->map)->long_name, ev_name);
2762
-
symbol__annotate_fprintf2(ms->sym, fp, opts);
2765
+
symbol__annotate_fprintf2(ms->sym, fp);
2763
2766
2764
2767
fclose(fp);
2765
2768
err = 0;
···
2936
2939
2937
2940
void annotation__update_column_widths(struct annotation *notes)
2938
2941
{
2939
-
if (notes->options->use_offset)
2942
+
if (annotate_opts.use_offset)
2940
2943
notes->widths.target = notes->widths.min_addr;
2941
-
else if (notes->options->full_addr)
2944
+
else if (annotate_opts.full_addr)
2942
2945
notes->widths.target = BITS_PER_LONG / 4;
2943
2946
else
2944
2947
notes->widths.target = notes->widths.max_addr;
2945
2948
2946
2949
notes->widths.addr = notes->widths.target;
2947
2950
2948
-
if (notes->options->show_nr_jumps)
2951
+
if (annotate_opts.show_nr_jumps)
2949
2952
notes->widths.addr += notes->widths.jumps + 1;
2950
2953
}
2951
2954
2952
2955
void annotation__toggle_full_addr(struct annotation *notes, struct map_symbol *ms)
2953
2956
{
2954
-
notes->options->full_addr = !notes->options->full_addr;
2957
+
annotate_opts.full_addr = !annotate_opts.full_addr;
2955
2958
2956
-
if (notes->options->full_addr)
2959
+
if (annotate_opts.full_addr)
2957
2960
notes->start = map__objdump_2mem(ms->map, ms->sym->start);
2958
2961
else
2959
2962
notes->start = map__rip_2objdump(ms->map, ms->sym->start);
···
2962
2965
}
2963
2966
2964
2967
static void annotation__calc_lines(struct annotation *notes, struct map *map,
2965
-
struct rb_root *root,
2966
-
struct annotation_options *opts)
2968
+
struct rb_root *root)
2967
2969
{
2968
2970
struct annotation_line *al;
2969
2971
struct rb_root tmp_root = RB_ROOT;
···
2975
2979
double percent;
2976
2980
2977
2981
percent = annotation_data__percent(&al->data[i],
2978
-
opts->percent_type);
2982
+
annotate_opts.percent_type);
2979
2983
2980
2984
if (percent > percent_max)
2981
2985
percent_max = percent;
···
2986
2990
2987
2991
al->path = get_srcline(map__dso(map), notes->start + al->offset, NULL,
2988
2992
false, true, notes->start + al->offset);
2989
-
insert_source_line(&tmp_root, al, opts);
2993
+
insert_source_line(&tmp_root, al);
2990
2994
}
2991
2995
2992
2996
resort_source_line(root, &tmp_root);
2993
2997
}
2994
2998
2995
-
static void symbol__calc_lines(struct map_symbol *ms, struct rb_root *root,
2996
-
struct annotation_options *opts)
2999
+
static void symbol__calc_lines(struct map_symbol *ms, struct rb_root *root)
2997
3000
{
2998
3001
struct annotation *notes = symbol__annotation(ms->sym);
2999
3002
3000
-
annotation__calc_lines(notes, ms->map, root, opts);
3003
+
annotation__calc_lines(notes, ms->map, root);
3001
3004
}
3002
3005
3003
-
int symbol__tty_annotate2(struct map_symbol *ms, struct evsel *evsel,
3004
-
struct annotation_options *opts)
3006
+
int symbol__tty_annotate2(struct map_symbol *ms, struct evsel *evsel)
3005
3007
{
3006
3008
struct dso *dso = map__dso(ms->map);
3007
3009
struct symbol *sym = ms->sym;
···
3008
3014
char buf[1024];
3009
3015
int err;
3010
3016
3011
-
err = symbol__annotate2(ms, evsel, opts, NULL);
3017
+
err = symbol__annotate2(ms, evsel, NULL);
3012
3018
if (err) {
3013
3019
char msg[BUFSIZ];
3014
3020
···
3018
3024
return -1;
3019
3025
}
3020
3026
3021
-
if (opts->print_lines) {
3022
-
srcline_full_filename = opts->full_path;
3023
-
symbol__calc_lines(ms, &source_line, opts);
3027
+
if (annotate_opts.print_lines) {
3028
+
srcline_full_filename = annotate_opts.full_path;
3029
+
symbol__calc_lines(ms, &source_line);
3024
3030
print_summary(&source_line, dso->long_name);
3025
3031
}
3026
3032
3027
3033
hists__scnprintf_title(hists, buf, sizeof(buf));
3028
3034
fprintf(stdout, "%s, [percent: %s]\n%s() %s\n",
3029
-
buf, percent_type_str(opts->percent_type), sym->name, dso->long_name);
3030
-
symbol__annotate_fprintf2(sym, stdout, opts);
3035
+
buf, percent_type_str(annotate_opts.percent_type), sym->name,
3036
+
dso->long_name);
3037
+
symbol__annotate_fprintf2(sym, stdout);
3031
3038
3032
3039
annotated_source__purge(symbol__annotation(sym)->src);
3033
3040
3034
3041
return 0;
3035
3042
}
3036
3043
3037
-
int symbol__tty_annotate(struct map_symbol *ms, struct evsel *evsel,
3038
-
struct annotation_options *opts)
3044
+
int symbol__tty_annotate(struct map_symbol *ms, struct evsel *evsel)
3039
3045
{
3040
3046
struct dso *dso = map__dso(ms->map);
3041
3047
struct symbol *sym = ms->sym;
3042
3048
struct rb_root source_line = RB_ROOT;
3043
3049
int err;
3044
3050
3045
-
err = symbol__annotate(ms, evsel, opts, NULL);
3051
+
err = symbol__annotate(ms, evsel, NULL);
3046
3052
if (err) {
3047
3053
char msg[BUFSIZ];
3048
3054
···
3054
3060
3055
3061
symbol__calc_percent(sym, evsel);
3056
3062
3057
-
if (opts->print_lines) {
3058
-
srcline_full_filename = opts->full_path;
3059
-
symbol__calc_lines(ms, &source_line, opts);
3063
+
if (annotate_opts.print_lines) {
3064
+
srcline_full_filename = annotate_opts.full_path;
3065
+
symbol__calc_lines(ms, &source_line);
3060
3066
print_summary(&source_line, dso->long_name);
3061
3067
}
3062
3068
3063
-
symbol__annotate_printf(ms, evsel, opts);
3069
+
symbol__annotate_printf(ms, evsel);
3064
3070
3065
3071
annotated_source__purge(symbol__annotation(sym)->src);
3066
3072
···
3121
3127
obj__printf(obj, " ");
3122
3128
}
3123
3129
3124
-
disasm_line__scnprintf(dl, bf, size, !notes->options->use_offset, notes->widths.max_ins_name);
3130
+
disasm_line__scnprintf(dl, bf, size, !annotate_opts.use_offset, notes->widths.max_ins_name);
3125
3131
}
3126
3132
3127
3133
static void ipc_coverage_string(char *bf, int size, struct annotation *notes)
···
3204
3210
else
3205
3211
obj__printf(obj, "%*s ", ANNOTATION__IPC_WIDTH - 1, "IPC");
3206
3212
3207
-
if (!notes->options->show_minmax_cycle) {
3213
+
if (!annotate_opts.show_minmax_cycle) {
3208
3214
if (al->cycles && al->cycles->avg)
3209
3215
obj__printf(obj, "%*" PRIu64 " ",
3210
3216
ANNOTATION__CYCLES_WIDTH - 1, al->cycles->avg);
···
3248
3254
if (!*al->line)
3249
3255
obj__printf(obj, "%-*s", width - pcnt_width - cycles_width, " ");
3250
3256
else if (al->offset == -1) {
3251
-
if (al->line_nr && notes->options->show_linenr)
3257
+
if (al->line_nr && annotate_opts.show_linenr)
3252
3258
printed = scnprintf(bf, sizeof(bf), "%-*d ", notes->widths.addr + 1, al->line_nr);
3253
3259
else
3254
3260
printed = scnprintf(bf, sizeof(bf), "%-*s ", notes->widths.addr, " ");
···
3258
3264
u64 addr = al->offset;
3259
3265
int color = -1;
3260
3266
3261
-
if (!notes->options->use_offset)
3267
+
if (!annotate_opts.use_offset)
3262
3268
addr += notes->start;
3263
3269
3264
-
if (!notes->options->use_offset) {
3270
+
if (!annotate_opts.use_offset) {
3265
3271
printed = scnprintf(bf, sizeof(bf), "%" PRIx64 ": ", addr);
3266
3272
} else {
3267
3273
if (al->jump_sources &&
3268
-
notes->options->offset_level >= ANNOTATION__OFFSET_JUMP_TARGETS) {
3269
-
if (notes->options->show_nr_jumps) {
3274
+
annotate_opts.offset_level >= ANNOTATION__OFFSET_JUMP_TARGETS) {
3275
+
if (annotate_opts.show_nr_jumps) {
3270
3276
int prev;
3271
3277
printed = scnprintf(bf, sizeof(bf), "%*d ",
3272
3278
notes->widths.jumps,
···
3280
3286
printed = scnprintf(bf, sizeof(bf), "%*" PRIx64 ": ",
3281
3287
notes->widths.target, addr);
3282
3288
} else if (ins__is_call(&disasm_line(al)->ins) &&
3283
-
notes->options->offset_level >= ANNOTATION__OFFSET_CALL) {
3289
+
annotate_opts.offset_level >= ANNOTATION__OFFSET_CALL) {
3284
3290
goto print_addr;
3285
-
} else if (notes->options->offset_level == ANNOTATION__MAX_OFFSET_LEVEL) {
3291
+
} else if (annotate_opts.offset_level == ANNOTATION__MAX_OFFSET_LEVEL) {
3286
3292
goto print_addr;
3287
3293
} else {
3288
3294
printed = scnprintf(bf, sizeof(bf), "%-*s ",
···
3304
3310
}
3305
3311
3306
3312
void annotation_line__write(struct annotation_line *al, struct annotation *notes,
3307
-
struct annotation_write_ops *wops,
3308
-
struct annotation_options *opts)
3313
+
struct annotation_write_ops *wops)
3309
3314
{
3310
3315
__annotation_line__write(al, notes, wops->first_line, wops->current_entry,
3311
3316
wops->change_color, wops->width, wops->obj,
3312
-
opts->percent_type,
3317
+
annotate_opts.percent_type,
3313
3318
wops->set_color, wops->set_percent_color,
3314
3319
wops->set_jumps_percent_color, wops->printf,
3315
3320
wops->write_graph);
3316
3321
}
3317
3322
3318
3323
int symbol__annotate2(struct map_symbol *ms, struct evsel *evsel,
3319
-
struct annotation_options *options, struct arch **parch)
3324
+
struct arch **parch)
3320
3325
{
3321
3326
struct symbol *sym = ms->sym;
3322
3327
struct annotation *notes = symbol__annotation(sym);
···
3329
3336
if (evsel__is_group_event(evsel))
3330
3337
nr_pcnt = evsel->core.nr_members;
3331
3338
3332
-
err = symbol__annotate(ms, evsel, options, parch);
3339
+
err = symbol__annotate(ms, evsel, parch);
3333
3340
if (err)
3334
3341
goto out_free_offsets;
3335
3342
3336
-
notes->options = options;
3343
+
notes->options = &annotate_opts;
3337
3344
3338
3345
symbol__calc_percent(sym, evsel);
3339
3346
···
3461
3468
return type;
3462
3469
}
3463
3470
3464
-
int annotate_parse_percent_type(const struct option *opt, const char *_str,
3471
+
int annotate_parse_percent_type(const struct option *opt __maybe_unused, const char *_str,
3465
3472
int unset __maybe_unused)
3466
3473
{
3467
-
struct annotation_options *opts = opt->value;
3468
3474
unsigned int type;
3469
3475
char *str1, *str2;
3470
3476
int err = -1;
···
3482
3490
if (type == (unsigned int) -1)
3483
3491
type = parse_percent_type(str2, str1);
3484
3492
if (type != (unsigned int) -1) {
3485
-
opts->percent_type = type;
3493
+
annotate_opts.percent_type = type;
3486
3494
err = 0;
3487
3495
}
3488
3496
+5
-10
tools/perf/util/annotate.h
+5
-10
tools/perf/util/annotate.h
···
224
224
};
225
225
226
226
void annotation_line__write(struct annotation_line *al, struct annotation *notes,
227
-
struct annotation_write_ops *ops,
228
-
struct annotation_options *opts);
227
+
struct annotation_write_ops *ops);
229
228
230
229
int __annotation__scnprintf_samples_period(struct annotation *notes,
231
230
char *bf, size_t size,
···
374
375
375
376
int symbol__annotate(struct map_symbol *ms,
376
377
struct evsel *evsel,
377
-
struct annotation_options *options,
378
378
struct arch **parch);
379
379
int symbol__annotate2(struct map_symbol *ms,
380
380
struct evsel *evsel,
381
-
struct annotation_options *options,
382
381
struct arch **parch);
383
382
384
383
enum symbol_disassemble_errno {
···
403
406
404
407
int symbol__strerror_disassemble(struct map_symbol *ms, int errnum, char *buf, size_t buflen);
405
408
406
-
int symbol__annotate_printf(struct map_symbol *ms, struct evsel *evsel,
407
-
struct annotation_options *options);
409
+
int symbol__annotate_printf(struct map_symbol *ms, struct evsel *evsel);
408
410
void symbol__annotate_zero_histogram(struct symbol *sym, int evidx);
409
411
void symbol__annotate_decay_histogram(struct symbol *sym, int evidx);
410
412
void annotated_source__purge(struct annotated_source *as);
411
413
412
-
int map_symbol__annotation_dump(struct map_symbol *ms, struct evsel *evsel,
413
-
struct annotation_options *opts);
414
+
int map_symbol__annotation_dump(struct map_symbol *ms, struct evsel *evsel);
414
415
415
416
bool ui__has_annotation(void);
416
417
417
-
int symbol__tty_annotate(struct map_symbol *ms, struct evsel *evsel, struct annotation_options *opts);
418
+
int symbol__tty_annotate(struct map_symbol *ms, struct evsel *evsel);
418
419
419
-
int symbol__tty_annotate2(struct map_symbol *ms, struct evsel *evsel, struct annotation_options *opts);
420
+
int symbol__tty_annotate2(struct map_symbol *ms, struct evsel *evsel);
420
421
421
422
#ifdef HAVE_SLANG_SUPPORT
422
423
int symbol__tui_annotate(struct map_symbol *ms, struct evsel *evsel,