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