xref: /linux/tools/perf/scripts/python/arm-cs-trace-disasm.py (revision 12fdd6c009da0d029ae54cff67242be02ea42a7a) 
1# SPDX-License-Identifier: GPL-2.0
2# arm-cs-trace-disasm.py: ARM CoreSight Trace Dump With Disassember
3#
4# Author: Tor Jeremiassen <tor@ti.com>
5#         Mathieu Poirier <mathieu.poirier@linaro.org>
6#         Leo Yan <leo.yan@linaro.org>
7#         Al Grant <Al.Grant@arm.com>
8
9from __future__ import print_function
10import os
11from os import path
12import sys
13import re
14from subprocess import *
15from optparse import OptionParser, make_option
16
17from perf_trace_context import perf_set_itrace_options, \
18	perf_sample_insn, perf_sample_srccode
19
20# Below are some example commands for using this script.
21#
22# Output disassembly with objdump:
23#  perf script -s scripts/python/arm-cs-trace-disasm.py \
24#		-- -d objdump -k path/to/vmlinux
25# Output disassembly with llvm-objdump:
26#  perf script -s scripts/python/arm-cs-trace-disasm.py \
27#		-- -d llvm-objdump-11 -k path/to/vmlinux
28# Output only source line and symbols:
29#  perf script -s scripts/python/arm-cs-trace-disasm.py
30
31# Command line parsing.
32option_list = [
33	# formatting options for the bottom entry of the stack
34	make_option("-k", "--vmlinux", dest="vmlinux_name",
35		    help="Set path to vmlinux file"),
36	make_option("-d", "--objdump", dest="objdump_name",
37		    help="Set path to objdump executable file"),
38	make_option("-v", "--verbose", dest="verbose",
39		    action="store_true", default=False,
40		    help="Enable debugging log")
41]
42
43parser = OptionParser(option_list=option_list)
44(options, args) = parser.parse_args()
45
46# Initialize global dicts and regular expression
47disasm_cache = dict()
48cpu_data = dict()
49disasm_re = re.compile("^\s*([0-9a-fA-F]+):")
50disasm_func_re = re.compile("^\s*([0-9a-fA-F]+)\s.*:")
51cache_size = 64*1024
52
53glb_source_file_name	= None
54glb_line_number		= None
55glb_dso			= None
56
57def get_optional(perf_dict, field):
58       if field in perf_dict:
59               return perf_dict[field]
60       return "[unknown]"
61
62def get_offset(perf_dict, field):
63	if field in perf_dict:
64		return f"+0x{perf_dict[field]:x}"
65	return ""
66
67def get_dso_file_path(dso_name, dso_build_id):
68	if (dso_name == "[kernel.kallsyms]" or dso_name == "vmlinux"):
69		if (options.vmlinux_name):
70			return options.vmlinux_name;
71		else:
72			return dso_name
73
74	if (dso_name == "[vdso]") :
75		append = "/vdso"
76	else:
77		append = "/elf"
78
79	dso_path = f"{os.environ['PERF_BUILDID_DIR']}/{dso_name}/{dso_build_id}{append}"
80	# Replace duplicate slash chars to single slash char
81	dso_path = dso_path.replace('//', '/', 1)
82	return dso_path
83
84def read_disam(dso_fname, dso_start, start_addr, stop_addr):
85	addr_range = str(start_addr) + ":" + str(stop_addr) + ":" + dso_fname
86
87	# Don't let the cache get too big, clear it when it hits max size
88	if (len(disasm_cache) > cache_size):
89		disasm_cache.clear();
90
91	if addr_range in disasm_cache:
92		disasm_output = disasm_cache[addr_range];
93	else:
94		start_addr = start_addr - dso_start;
95		stop_addr = stop_addr - dso_start;
96		disasm = [ options.objdump_name, "-d", "-z",
97			   f"--start-address=0x{start_addr:x}",
98			   f"--stop-address=0x{stop_addr:x}" ]
99		disasm += [ dso_fname ]
100		disasm_output = check_output(disasm).decode('utf-8').split('\n')
101		disasm_cache[addr_range] = disasm_output
102
103	return disasm_output
104
105def print_disam(dso_fname, dso_start, start_addr, stop_addr):
106	for line in read_disam(dso_fname, dso_start, start_addr, stop_addr):
107		m = disasm_func_re.search(line)
108		if m is None:
109			m = disasm_re.search(line)
110			if m is None:
111				continue
112		print(f"\t{line}")
113
114def print_sample(sample):
115	print(f"Sample = {{ cpu: {sample['cpu']:04} addr: 0x{sample['addr']:016x} " \
116	      f"phys_addr: 0x{sample['phys_addr']:016x} ip: 0x{sample['ip']:016x} " \
117	      f"pid: {sample['pid']} tid: {sample['tid']} period: {sample['period']} time: {sample['time']} }}")
118
119def trace_begin():
120	print('ARM CoreSight Trace Data Assembler Dump')
121
122def trace_end():
123	print('End')
124
125def trace_unhandled(event_name, context, event_fields_dict):
126	print(' '.join(['%s=%s'%(k,str(v))for k,v in sorted(event_fields_dict.items())]))
127
128def common_start_str(comm, sample):
129	sec = int(sample["time"] / 1000000000)
130	ns = sample["time"] % 1000000000
131	cpu = sample["cpu"]
132	pid = sample["pid"]
133	tid = sample["tid"]
134	return f"{comm:>16} {pid:>5}/{tid:<5} [{cpu:04}] {sec:9}.{ns:09}  "
135
136# This code is copied from intel-pt-events.py for printing source code
137# line and symbols.
138def print_srccode(comm, param_dict, sample, symbol, dso):
139	ip = sample["ip"]
140	if symbol == "[unknown]":
141		start_str = common_start_str(comm, sample) + ("%x" % ip).rjust(16).ljust(40)
142	else:
143		offs = get_offset(param_dict, "symoff")
144		start_str = common_start_str(comm, sample) + (symbol + offs).ljust(40)
145
146	global glb_source_file_name
147	global glb_line_number
148	global glb_dso
149
150	source_file_name, line_number, source_line = perf_sample_srccode(perf_script_context)
151	if source_file_name:
152		if glb_line_number == line_number and glb_source_file_name == source_file_name:
153			src_str = ""
154		else:
155			if len(source_file_name) > 40:
156				src_file = ("..." + source_file_name[-37:]) + " "
157			else:
158				src_file = source_file_name.ljust(41)
159
160			if source_line is None:
161				src_str = src_file + str(line_number).rjust(4) + " <source not found>"
162			else:
163				src_str = src_file + str(line_number).rjust(4) + " " + source_line
164		glb_dso = None
165	elif dso == glb_dso:
166		src_str = ""
167	else:
168		src_str = dso
169		glb_dso = dso
170
171	glb_line_number = line_number
172	glb_source_file_name = source_file_name
173
174	print(f"{start_str}{src_str}")
175
176def process_event(param_dict):
177	global cache_size
178	global options
179
180	sample = param_dict["sample"]
181	comm = param_dict["comm"]
182
183	name = param_dict["ev_name"]
184	dso = get_optional(param_dict, "dso")
185	dso_bid = get_optional(param_dict, "dso_bid")
186	dso_start = get_optional(param_dict, "dso_map_start")
187	dso_end = get_optional(param_dict, "dso_map_end")
188	symbol = get_optional(param_dict, "symbol")
189
190	if (options.verbose == True):
191		print(f"Event type: {name}")
192		print_sample(sample)
193
194	# If cannot find dso so cannot dump assembler, bail out
195	if (dso == '[unknown]'):
196		return
197
198	# Validate dso start and end addresses
199	if ((dso_start == '[unknown]') or (dso_end == '[unknown]')):
200		print(f"Failed to find valid dso map for dso {dso}")
201		return
202
203	if (name[0:12] == "instructions"):
204		print_srccode(comm, param_dict, sample, symbol, dso)
205		return
206
207	# Don't proceed if this event is not a branch sample, .
208	if (name[0:8] != "branches"):
209		return
210
211	cpu = sample["cpu"]
212	ip = sample["ip"]
213	addr = sample["addr"]
214
215	# Initialize CPU data if it's empty, and directly return back
216	# if this is the first tracing event for this CPU.
217	if (cpu_data.get(str(cpu) + 'addr') == None):
218		cpu_data[str(cpu) + 'addr'] = addr
219		return
220
221	# The format for packet is:
222	#
223	#		  +------------+------------+------------+
224	#  sample_prev:   |    addr    |    ip	    |	 cpu	 |
225	#		  +------------+------------+------------+
226	#  sample_next:   |    addr    |    ip	    |	 cpu	 |
227	#		  +------------+------------+------------+
228	#
229	# We need to combine the two continuous packets to get the instruction
230	# range for sample_prev::cpu:
231	#
232	#     [ sample_prev::addr .. sample_next::ip ]
233	#
234	# For this purose, sample_prev::addr is stored into cpu_data structure
235	# and read back for 'start_addr' when the new packet comes, and we need
236	# to use sample_next::ip to calculate 'stop_addr', plusing extra 4 for
237	# 'stop_addr' is for the sake of objdump so the final assembler dump can
238	# include last instruction for sample_next::ip.
239	start_addr = cpu_data[str(cpu) + 'addr']
240	stop_addr  = ip + 4
241
242	# Record for previous sample packet
243	cpu_data[str(cpu) + 'addr'] = addr
244
245	# Handle CS_ETM_TRACE_ON packet if start_addr=0 and stop_addr=4
246	if (start_addr == 0 and stop_addr == 4):
247		print(f"CPU{cpu}: CS_ETM_TRACE_ON packet is inserted")
248		return
249
250	if (start_addr < int(dso_start) or start_addr > int(dso_end)):
251		print(f"Start address 0x{start_addr:x} is out of range [ 0x{dso_start:x} .. 0x{dso_end:x} ] for dso {dso}")
252		return
253
254	if (stop_addr < int(dso_start) or stop_addr > int(dso_end)):
255		print(f"Stop address 0x{stop_addr:x} is out of range [ 0x{dso_start:x} .. 0x{dso_end:x} ] for dso {dso}")
256		return
257
258	if (options.objdump_name != None):
259		# It doesn't need to decrease virtual memory offset for disassembly
260		# for kernel dso, so in this case we set vm_start to zero.
261		if (dso == "[kernel.kallsyms]"):
262			dso_vm_start = 0
263		else:
264			dso_vm_start = int(dso_start)
265
266		dso_fname = get_dso_file_path(dso, dso_bid)
267		if path.exists(dso_fname):
268			print_disam(dso_fname, dso_vm_start, start_addr, stop_addr)
269		else:
270			print(f"Failed to find dso {dso} for address range [ 0x{start_addr:x} .. 0x{stop_addr:x} ]")
271
272	print_srccode(comm, param_dict, sample, symbol, dso)
273