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