decoders/arm_etmv3/pd.py

   1 ##
   2 ## This file is part of the libsigrokdecode project.
   3 ##
   4 ## Copyright (C) 2015 Petteri Aimonen <jpa@sigrok.mail.kapsi.fi>
   5 ##
   6 ## This program is free software; you can redistribute it and/or modify
   7 ## it under the terms of the GNU General Public License as published by
   8 ## the Free Software Foundation; either version 2 of the License, or
   9 ## (at your option) any later version.
  10 ##
  11 ## This program is distributed in the hope that it will be useful,
  12 ## but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ## GNU General Public License for more details.
  15 ##
  16 ## You should have received a copy of the GNU General Public License
  17 ## along with this program; if not, write to the Free Software
  18 ## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19 ##
  20
  21 import sigrokdecode as srd
  22 import subprocess
  23 import re
  24
  25 # See ETMv3 Signal Protocol table 7-11: 'Encoding of Exception[8:0]'.
  26 exc_names = [
  27     'No exception', 'IRQ1', 'IRQ2', 'IRQ3', 'IRQ4', 'IRQ5', 'IRQ6', 'IRQ7',
  28     'IRQ0', 'UsageFault', 'NMI', 'SVC', 'DebugMon', 'MemManage', 'PendSV',
  29     'SysTick', 'Reserved', 'Reset', 'BusFault', 'Reserved', 'Reserved'
  30 ]
  31
  32 for i in range(8, 496):
  33     exc_names.append('IRQ%d' % i)
  34
  35 def parse_varint(bytes):
  36     '''Parse an integer where the top bit is the continuation bit.
  37     Returns value and number of parsed bytes.'''
  38     v = 0
  39     for i, b in enumerate(bytes):
  40         v |= (b & 0x7F) << (i * 7)
  41         if b & 0x80 == 0:
  42             return v, i+1
  43     return v, len(bytes)
  44
  45 def parse_uint(bytes):
  46     '''Parse little-endian integer.'''
  47     v = 0
  48     for i, b in enumerate(bytes):
  49         v |= b << (i * 8)
  50     return v
  51
  52 def parse_exc_info(bytes):
  53     '''Parse exception information bytes from a branch packet.'''
  54     if len(bytes) < 1:
  55         return None
  56
  57     excv, exclen = parse_varint(bytes)
  58     if bytes[exclen - 1] & 0x80 != 0x00:
  59         return None # Exception info not complete.
  60
  61     if exclen == 2 and excv & (1 << 13):
  62         # Exception byte 1 was skipped, fix up the decoding.
  63         excv = (excv & 0x7F) | ((excv & 0x3F80) << 7)
  64
  65     ns = excv & 1
  66     exc = ((excv >> 1) & 0x0F) | ((excv >> 7) & 0x1F0)
  67     cancel = (excv >> 5) & 1
  68     altisa = (excv >> 6) & 1
  69     hyp = (excv >> 12) & 1
  70     resume = (excv >> 14) & 0x0F
  71     return (ns, exc, cancel, altisa, hyp, resume)
  72
  73 def parse_branch_addr(bytes, ref_addr, cpu_state, branch_enc):
  74     '''Parse encoded branch address.
  75        Returns addr, addrlen, cpu_state, exc_info.
  76        Returns None if packet is not yet complete'''
  77
  78     addr, addrlen = parse_varint(bytes)
  79
  80     if bytes[addrlen-1] & 0x80 != 0x00:
  81         return None # Branch address not complete.
  82
  83     addr_bits = 7 * addrlen
  84
  85     have_exc_info = False
  86     if branch_enc == 'original':
  87         if addrlen == 5 and bytes[4] & 0x40:
  88             have_exc_info = True
  89     elif branch_enc == 'alternative':
  90         addr_bits -= 1 # Top bit of address indicates exc_info.
  91         if addrlen >= 2 and addr & (1 << addr_bits):
  92             have_exc_info = True
  93             addr &= ~(1 << addr_bits)
  94
  95     exc_info = None
  96     if have_exc_info:
  97         exc_info = parse_exc_info(bytes[addrlen:])
  98         if exc_info is None:
  99             return None # Exception info not complete.
 100
 101     if addrlen == 5:
 102         # Possible change in CPU state.
 103         if bytes[4] & 0xB8 == 0x08:
 104             cpu_state = 'arm'
 105         elif bytes[4] & 0xB0 == 0x10:
 106             cpu_state = 'thumb'
 107         elif bytes[4] & 0xA0 == 0x20:
 108             cpu_state = 'jazelle'
 109         else:
 110             raise NotImplementedError('Unhandled branch byte 4: 0x%02x' % bytes[4])
 111
 112     # Shift the address according to current CPU state.
 113     if cpu_state == 'arm':
 114         addr = (addr & 0xFFFFFFFE) << 1
 115         addr_bits += 1
 116     elif cpu_state == 'thumb':
 117         addr = addr & 0xFFFFFFFE
 118     elif cpu_state == 'jazelle':
 119         addr = (addr & 0xFFFFFFFFE) >> 1
 120         addr_bits -= 1
 121     else:
 122         raise NotImplementedError('Unhandled state: ' + cpu_state)
 123
 124     # If the address wasn't full, fill in with the previous address.
 125     if addrlen < 5:
 126         addr |= ref_addr & (0xFFFFFFFF << addr_bits)
 127
 128     return addr, addrlen, cpu_state, exc_info
 129
 130 class Decoder(srd.Decoder):
 131     api_version = 2
 132     id = 'arm_etmv3'
 133     name = 'ARM ETMv3'
 134     longname = 'ARM Embedded Trace Macroblock'
 135     desc = 'Decode ETM instruction trace packets.'
 136     license = 'gplv2+'
 137     inputs = ['uart']
 138     outputs = ['arm_etmv3']
 139     annotations = (
 140         ('trace', 'Trace info'),
 141         ('branch', 'Branches'),
 142         ('exception', 'Exceptions'),
 143         ('execution', 'Instruction execution'),
 144         ('data', 'Data access'),
 145         ('pc', 'Program counter'),
 146         ('instr_e', 'Executed instructions'),
 147         ('instr_n', 'Not executed instructions'),
 148         ('source', 'Source code'),
 149         ('location', 'Current location'),
 150         ('function', 'Current function'),
 151     )
 152     annotation_rows = (
 153         ('trace', 'Trace info', (0,)),
 154         ('flow', 'Code flow', (1, 2, 3,)),
 155         ('data', 'Data access', (4,)),
 156         ('pc', 'Program counter', (5,)),
 157         ('instruction', 'Instructions', (6, 7,)),
 158         ('source', 'Source code', (8,)),
 159         ('location', 'Current location', (9,)),
 160         ('function', 'Current function', (10,)),
 161     )
 162     options = (
 163         {'id': 'objdump', 'desc': 'objdump path',
 164             'default': 'arm-none-eabi-objdump'},
 165         {'id': 'objdump_opts', 'desc': 'objdump options',
 166             'default': '-lSC'},
 167         {'id': 'elffile', 'desc': '.elf path',
 168             'default': ''},
 169         {'id': 'branch_enc', 'desc': 'Branch encoding',
 170             'default': 'alternative', 'values': ('alternative', 'original')},
 171     )
 172
 173     def __init__(self):
 174         self.buf = []
 175         self.syncbuf = []
 176         self.prevsample = 0
 177         self.last_branch = 0
 178         self.cpu_state = 'arm'
 179         self.current_pc = 0
 180         self.current_loc = None
 181         self.current_func = None
 182         self.next_instr_lookup = {}
 183         self.file_lookup = {}
 184         self.func_lookup = {}
 185         self.disasm_lookup = {}
 186         self.source_lookup = {}
 187
 188     def start(self):
 189         self.out_ann = self.register(srd.OUTPUT_ANN)
 190         self.load_objdump()
 191
 192     def load_objdump(self):
 193         '''Parse disassembly obtained from objdump into two tables:
 194         next_instr_lookup: Find the next PC addr from current PC.
 195         disasm_lookup: Find the instruction text from current PC.
 196         source_lookup: Find the source code line from current PC.
 197         '''
 198         if not (self.options['objdump'] and self.options['elffile']):
 199             return
 200
 201         opts = [self.options['objdump']]
 202         opts += self.options['objdump_opts'].split()
 203         opts += [self.options['elffile']]
 204
 205         try:
 206             disasm = subprocess.check_output(opts)
 207         except subprocess.CalledProcessError:
 208             return
 209
 210         disasm = disasm.decode('utf-8', 'replace')
 211
 212         instpat = re.compile('\s*([0-9a-fA-F]+):\t+([0-9a-fA-F ]+)\t+([a-zA-Z][^;]+)\s*;?.*')
 213         branchpat = re.compile('(b|bl|b..|bl..|cbnz|cbz)(?:\.[wn])?\s+(?:r[0-9]+,\s*)?([0-9a-fA-F]+)')
 214         filepat = re.compile('[^\s]+[/\\\\]([a-zA-Z0-9._-]+:[0-9]+)(?:\s.*)?')
 215         funcpat = re.compile('[0-9a-fA-F]+\s*<([^>]+)>:.*')
 216
 217         prev_src = ''
 218         prev_file = ''
 219         prev_func = ''
 220
 221         for line in disasm.split('\n'):
 222             m = instpat.match(line)
 223             if m:
 224                 addr = int(m.group(1), 16)
 225                 raw = m.group(2)
 226                 disas = m.group(3).strip().replace('\t', ' ')
 227                 self.disasm_lookup[addr] = disas
 228                 self.source_lookup[addr] = prev_src
 229                 self.file_lookup[addr] = prev_file
 230                 self.func_lookup[addr] = prev_func
 231
 232                 # Next address in direct sequence.
 233                 ilen = len(raw.replace(' ', '')) // 2
 234                 next_n = addr + ilen
 235
 236                 # Next address if branch is taken.
 237                 bm = branchpat.match(disas)
 238                 if bm:
 239                     next_e = int(bm.group(2), 16)
 240                 else:
 241                     next_e = next_n
 242
 243                 self.next_instr_lookup[addr] = (next_n, next_e)
 244             else:
 245                 m = funcpat.match(line)
 246                 if m:
 247                     prev_func = m.group(1)
 248                     prev_src = None
 249                 else:
 250                     m = filepat.match(line)
 251                     if m:
 252                         prev_file = m.group(1)
 253                         prev_src = None
 254                     else:
 255                         prev_src = line.strip()
 256
 257     def flush_current_loc(self):
 258         if self.current_loc is not None:
 259             ss, es, loc, src = self.current_loc
 260             if loc:
 261                 self.put(ss, es, self.out_ann, [9, [loc]])
 262             if src:
 263                 self.put(ss, es, self.out_ann, [8, [src]])
 264             self.current_loc = None
 265
 266     def flush_current_func(self):
 267         if self.current_func is not None:
 268             ss, es, func = self.current_func
 269             if func:
 270                 self.put(ss, es, self.out_ann, [10, [func]])
 271             self.current_func = None
 272
 273     def instructions_executed(self, exec_status):
 274         '''Advance program counter based on executed instructions.
 275         Argument is a list of False for not executed and True for executed
 276         instructions.
 277         '''
 278
 279         if len(exec_status) == 0:
 280             return
 281
 282         tdelta = max(1, (self.prevsample - self.startsample) / len(exec_status))
 283
 284         for i, exec_status in enumerate(exec_status):
 285             pc = self.current_pc
 286             default_next = pc + 2 if self.cpu_state == 'thumb' else pc + 4
 287             target_n, target_e = self.next_instr_lookup.get(pc, (default_next, default_next))
 288             ss = self.startsample + round(tdelta * i)
 289             es = self.startsample + round(tdelta * (i+1))
 290
 291             self.put(ss, es, self.out_ann,
 292                      [5, ['PC 0x%08x' % pc, '0x%08x' % pc, '%08x' % pc]])
 293
 294             new_loc = self.file_lookup.get(pc)
 295             new_src = self.source_lookup.get(pc)
 296             new_dis = self.disasm_lookup.get(pc)
 297             new_func = self.func_lookup.get(pc)
 298
 299             # Report source line only when it changes.
 300             if self.current_loc is not None:
 301                 if new_loc != self.current_loc[2] or new_src != self.current_loc[3]:
 302                     self.flush_current_loc()
 303
 304             if self.current_loc is None:
 305                 self.current_loc = [ss, es, new_loc, new_src]
 306             else:
 307                 self.current_loc[1] = es
 308
 309             # Report function name only when it changes.
 310             if self.current_func is not None:
 311                 if new_func != self.current_func[2]:
 312                     self.flush_current_func()
 313
 314             if self.current_func is None:
 315                 self.current_func = [ss, es, new_func]
 316             else:
 317                 self.current_func[1] = es
 318
 319             # Report instruction every time.
 320             if new_dis:
 321                 if exec_status:
 322                     a = [6, ['Executed: ' + new_dis, new_dis, new_dis.split()[0]]]
 323                 else:
 324                     a = [7, ['Not executed: ' + new_dis, new_dis, new_dis.split()[0]]]
 325                 self.put(ss, es, self.out_ann, a)
 326
 327             if exec_status:
 328                 self.current_pc = target_e
 329             else:
 330                 self.current_pc = target_n
 331
 332     def get_packet_type(self, byte):
 333         '''Identify packet type based on its first byte.
 334            See ARM IHI0014Q section "ETMv3 Signal Protocol" "Packet Types"
 335         '''
 336         if byte & 0x01 == 0x01:
 337             return 'branch'
 338         elif byte == 0x00:
 339             return 'a_sync'
 340         elif byte == 0x04:
 341             return 'cyclecount'
 342         elif byte == 0x08:
 343             return 'i_sync'
 344         elif byte == 0x0C:
 345             return 'trigger'
 346         elif byte & 0xF3 in (0x20, 0x40, 0x60):
 347             return 'ooo_data'
 348         elif byte == 0x50:
 349             return 'store_failed'
 350         elif byte == 0x70:
 351             return 'i_sync'
 352         elif byte & 0xDF in (0x54, 0x58, 0x5C):
 353             return 'ooo_place'
 354         elif byte == 0x3C:
 355             return 'vmid'
 356         elif byte & 0xD3 == 0x02:
 357             return 'data'
 358         elif byte & 0xFB == 0x42:
 359             return 'timestamp'
 360         elif byte == 0x62:
 361             return 'data_suppressed'
 362         elif byte == 0x66:
 363             return 'ignore'
 364         elif byte & 0xEF == 0x6A:
 365             return 'value_not_traced'
 366         elif byte == 0x6E:
 367             return 'context_id'
 368         elif byte == 0x76:
 369             return 'exception_exit'
 370         elif byte == 0x7E:
 371             return 'exception_entry'
 372         elif byte & 0x81 == 0x80:
 373             return 'p_header'
 374         else:
 375             return 'unknown'
 376
 377     def fallback(self, buf):
 378         ptype = self.get_packet_type(buf[0])
 379         return [0, ['Unhandled ' + ptype + ': ' + ' '.join(['%02x' % b for b in buf])]]
 380
 381     def handle_a_sync(self, buf):
 382         if buf[-1] == 0x80:
 383             return [0, ['Synchronization']]
 384
 385     def handle_exception_exit(self, buf):
 386         return [2, ['Exception exit']]
 387
 388     def handle_exception_entry(self, buf):
 389         return [2, ['Exception entry']]
 390
 391     def handle_i_sync(self, buf):
 392         contextid_bytes = 0 # This is the default ETM config.
 393
 394         if len(buf) < 6:
 395             return None # Packet definitely not full yet.
 396
 397         if buf[0] == 0x08: # No cycle count.
 398             cyclecount = None
 399             idx = 1 + contextid_bytes # Index to info byte.
 400         elif buf[0] == 0x70: # With cycle count.
 401             cyclecount, cyclen = parse_varint(buf[1:6])
 402             idx = 1 + cyclen + contextid_bytes
 403
 404         if len(buf) <= idx + 4:
 405             return None
 406         infobyte = buf[idx]
 407         addr = parse_uint(buf[idx+1:idx+5])
 408
 409         reasoncode = (infobyte >> 5) & 3
 410         reason = ('Periodic', 'Tracing enabled', 'After overflow', 'Exit from debug')[reasoncode]
 411         jazelle = (infobyte >> 4) & 1
 412         nonsec = (infobyte >> 3) & 1
 413         altisa = (infobyte >> 2) & 1
 414         hypervisor = (infobyte >> 1) & 1
 415         thumb = addr & 1
 416         addr &= 0xFFFFFFFE
 417
 418         if reasoncode == 0 and self.current_pc != addr:
 419             self.put(self.startsample, self.prevsample, self.out_ann,
 420                      [0, ['WARN: Unexpected PC change 0x%08x -> 0x%08x' % \
 421                      (self.current_pc, addr)]])
 422         elif reasoncode != 0:
 423             # Reset location when the trace has been interrupted.
 424             self.flush_current_loc()
 425             self.flush_current_func()
 426
 427         self.last_branch = addr
 428         self.current_pc = addr
 429
 430         if jazelle:
 431             self.cpu_state = 'jazelle'
 432         elif thumb:
 433             self.cpu_state = 'thumb'
 434         else:
 435             self.cpu_state = 'arm'
 436
 437         cycstr = ''
 438         if cyclecount is not None:
 439             cycstr = ', cyclecount %d' % cyclecount
 440
 441         if infobyte & 0x80: # LSIP packet
 442             self.put(self.startsample, self.prevsample, self.out_ann,
 443                      [0, ['WARN: LSIP I-Sync packet not implemented']])
 444
 445         return [0, ['I-Sync: %s, PC 0x%08x, %s state%s' % \
 446                     (reason, addr, self.cpu_state, cycstr), \
 447                     'I-Sync: %s 0x%08x' % (reason, addr)]]
 448
 449     def handle_trigger(self, buf):
 450         return [0, ['Trigger event', 'Trigger']]
 451
 452     def handle_p_header(self, buf):
 453         # Only non cycle-accurate mode supported.
 454         if buf[0] & 0x83 == 0x80:
 455             n = (buf[0] >> 6) & 1
 456             e = (buf[0] >> 2) & 15
 457
 458             self.instructions_executed([1] * e + [0] * n)
 459
 460             if n:
 461                 return [3, ['%d instructions executed, %d skipped due to ' \
 462                             'condition codes' % (e, n),
 463                             '%d ins exec, %d skipped' % (e, n),
 464                             '%dE,%dN' % (e, n)]]
 465             else:
 466                 return [3, ['%d instructions executed' % e,
 467                             '%d ins exec' % e, '%dE' % e]]
 468         elif buf[0] & 0xF3 == 0x82:
 469             i1 = (buf[0] >> 3) & 1
 470             i2 = (buf[0] >> 2) & 1
 471             self.instructions_executed([not i1, not i2])
 472             txt1 = ('executed', 'skipped')
 473             txt2 = ('E', 'S')
 474             return [3, ['Instruction 1 %s, instruction 2 %s' % (txt1[i1], txt1[i2]),
 475                         'I1 %s, I2 %s' % (txt2[i1], txt2[i2]),
 476                         '%s,%s' % (txt2[i1], txt2[i2])]]
 477         else:
 478             return self.fallback(buf)
 479
 480     def handle_branch(self, buf):
 481         if buf[-1] & 0x80 != 0x00:
 482             return None # Not complete yet.
 483
 484         brinfo = parse_branch_addr(buf, self.last_branch, self.cpu_state,
 485                                    self.options['branch_enc'])
 486
 487         if brinfo is None:
 488             return None # Not complete yet.
 489
 490         addr, addrlen, cpu_state, exc_info = brinfo
 491         self.last_branch = addr
 492         self.current_pc = addr
 493
 494         txt = ''
 495
 496         if cpu_state != self.cpu_state:
 497             txt += ', to %s state' % cpu_state
 498             self.cpu_state = cpu_state
 499
 500         annidx = 1
 501
 502         if exc_info:
 503             annidx = 2
 504             ns, exc, cancel, altisa, hyp, resume = exc_info
 505             if ns:
 506                 txt += ', to non-secure state'
 507             if exc:
 508                 if exc < len(exc_names):
 509                     txt += ', exception %s' % exc_names[exc]
 510                 else:
 511                     txt += ', exception 0x%02x' % exc
 512             if cancel:
 513                 txt += ', instr cancelled'
 514             if altisa:
 515                 txt += ', to AltISA'
 516             if hyp:
 517                 txt += ', to hypervisor'
 518             if resume:
 519                 txt += ', instr resume 0x%02x' % resume
 520
 521         return [annidx, ['Branch to 0x%08x%s' % (addr, txt),
 522                          'B 0x%08x%s' % (addr, txt)]]
 523
 524     def decode(self, ss, es, data):
 525         ptype, rxtx, pdata = data
 526
 527         if ptype != 'DATA':
 528             return
 529
 530         # Reset packet if there is a long pause between bytes.
 531         # This helps getting the initial synchronization.
 532         self.byte_len = es - ss
 533         if ss - self.prevsample > 16 * self.byte_len:
 534             self.flush_current_loc()
 535             self.flush_current_func()
 536             self.buf = []
 537         self.prevsample = es
 538
 539         self.buf.append(pdata[0])
 540
 541         # Store the start time of the packet.
 542         if len(self.buf) == 1:
 543             self.startsample = ss
 544
 545         # Keep separate buffer for detection of sync packets.
 546         # Sync packets override everything else, so that we can regain sync
 547         # even if some packets are corrupted.
 548         self.syncbuf = self.syncbuf[-4:] + [pdata[0]]
 549         if self.syncbuf == [0x00, 0x00, 0x00, 0x00, 0x80]:
 550             self.buf = self.syncbuf
 551             self.syncbuf = []
 552
 553         # See if it is ready to be decoded.
 554         ptype = self.get_packet_type(self.buf[0])
 555         if hasattr(self, 'handle_' + ptype):
 556             func = getattr(self, 'handle_' + ptype)
 557             data = func(self.buf)
 558         else:
 559             data = self.fallback(self.buf)
 560
 561         if data is not None:
 562             if data:
 563                 self.put(self.startsample, es, self.out_ann, data)
 564             self.buf = []