diff options
Diffstat (limited to 'scripts/stack_core.py')
| -rwxr-xr-x | scripts/stack_core.py | 436 |
1 files changed, 328 insertions, 108 deletions
diff --git a/scripts/stack_core.py b/scripts/stack_core.py index 42285d462..056f6073f 100755 --- a/scripts/stack_core.py +++ b/scripts/stack_core.py @@ -17,108 +17,148 @@ """stack symbolizes native crash dumps.""" import re - import symbol - -def PrintTraceLines(trace_lines): - """Print back trace.""" - maxlen = max(map(lambda tl: len(tl[1]), trace_lines)) - print - print "Stack Trace:" - print " RELADDR " + "FUNCTION".ljust(maxlen) + " FILE:LINE" - for tl in trace_lines: - (addr, symbol_with_offset, location) = tl - print " %8s %s %s" % (addr, symbol_with_offset.ljust(maxlen), location) - return - - -def PrintValueLines(value_lines): - """Print stack data values.""" - maxlen = max(map(lambda tl: len(tl[2]), value_lines)) - print - print "Stack Data:" - print " ADDR VALUE " + "FUNCTION".ljust(maxlen) + " FILE:LINE" - for vl in value_lines: - (addr, value, symbol_with_offset, location) = vl - print " %8s %8s %s %s" % (addr, value, symbol_with_offset.ljust(maxlen), location) - return - -UNKNOWN = "<unknown>" -HEAP = "[heap]" -STACK = "[stack]" - - -def PrintOutput(trace_lines, value_lines): - if trace_lines: - PrintTraceLines(trace_lines) - if value_lines: - PrintValueLines(value_lines) - -def PrintDivider(): - print - print "-----------------------------------------------------\n" +import unittest def ConvertTrace(lines): - """Convert strings containing native crash to a stack.""" + tracer = TraceConverter() + print "Reading symbols from", symbol.SYMBOLS_DIR + tracer.ConvertTrace(lines) + +class TraceConverter: process_info_line = re.compile("(pid: [0-9]+, tid: [0-9]+.*)") + abi_line = re.compile("(ABI: \'(.*)\')") signal_line = re.compile("(signal [0-9]+ \(.*\).*)") - register_line = re.compile("(([ ]*[0-9a-z]{2} [0-9a-f]{8}){4})") + abort_message_line = re.compile("(Abort message: '.*')") thread_line = re.compile("(.*)(\-\-\- ){15}\-\-\-") dalvik_jni_thread_line = re.compile("(\".*\" prio=[0-9]+ tid=[0-9]+ NATIVE.*)") dalvik_native_thread_line = re.compile("(\".*\" sysTid=[0-9]+ nice=[0-9]+.*)") - # Note that both trace and value line matching allow for variable amounts of - # whitespace (e.g. \t). This is because the we want to allow for the stack - # tool to operate on AndroidFeedback provided system logs. AndroidFeedback - # strips out double spaces that are found in tombsone files and logcat output. - # - # Examples of matched trace lines include lines from tombstone files like: - # #00 pc 001cf42e /data/data/com.my.project/lib/libmyproject.so - # #00 pc 001cf42e /data/data/com.my.project/lib/libmyproject.so (symbol) - # Or lines from AndroidFeedback crash report system logs like: - # 03-25 00:51:05.520 I/DEBUG ( 65): #00 pc 001cf42e /data/data/com.my.project/lib/libmyproject.so - # Please note the spacing differences. - trace_line = re.compile("(.*)\#([0-9]+)[ \t]+(..)[ \t]+([0-9a-f]{8})[ \t]+([^\r\n \t]*)( \((.*)\))?") # pylint: disable-msg=C6310 - # Examples of matched value lines include: - # bea4170c 8018e4e9 /data/data/com.my.project/lib/libmyproject.so - # bea4170c 8018e4e9 /data/data/com.my.project/lib/libmyproject.so (symbol) - # 03-25 00:51:05.530 I/DEBUG ( 65): bea4170c 8018e4e9 /data/data/com.my.project/lib/libmyproject.so - # Again, note the spacing differences. - value_line = re.compile("(.*)([0-9a-f]{8})[ \t]+([0-9a-f]{8})[ \t]+([^\r\n \t]*)( \((.*)\))?") - # Lines from 'code around' sections of the output will be matched before - # value lines because otheriwse the 'code around' sections will be confused as - # value lines. - # - # Examples include: - # 801cf40c ffffc4cc 00b2f2c5 00b2f1c7 00c1e1a8 - # 03-25 00:51:05.530 I/DEBUG ( 65): 801cf40c ffffc4cc 00b2f2c5 00b2f1c7 00c1e1a8 - code_line = re.compile("(.*)[ \t]*[a-f0-9]{8}[ \t]*[a-f0-9]{8}[ \t]*[a-f0-9]{8}[ \t]*[a-f0-9]{8}[ \t]*[a-f0-9]{8}[ \t]*[ \r\n]") # pylint: disable-msg=C6310 - + register_line = re.compile("$a") + trace_line = re.compile("$a") + value_line = re.compile("$a") + code_line = re.compile("$a") trace_lines = [] value_lines = [] last_frame = -1 + width = "{8}" + + def __init__(self): pass + + register_names = { + "arm": "r0|r1|r2|r3|r4|r5|r6|r7|r8|r9|sl|fp|ip|sp|lr|pc|cpsr", + "arm64": "x0|x1|x2|x3|x4|x5|x6|x7|x8|x9|x10|x11|x12|x13|x14|x15|x16|x17|x18|x19|x20|x21|x22|x23|x24|x25|x26|x27|x28|x29|x30|sp|pc", + "mips": "zr|at|v0|v1|a0|a1|a2|a3|t0|t1|t2|t3|t4|t5|t6|t7|s0|s1|s2|s3|s4|s5|s6|s7|t8|t9|k0|k1|gp|sp|s8|ra|hi|lo|bva|epc", + "x86": "eax|ebx|ecx|edx|esi|edi|x?cs|x?ds|x?es|x?fs|x?ss|eip|ebp|esp|flags", + "x86_64": "rax|rbx|rcx|rdx|rsi|rdi|r8|r9|r10|r11|r12|r13|r14|r15|cs|ss|rip|rbp|rsp|eflags", + } + + def UpdateAbiRegexes(self): + if symbol.ARCH == "arm64" or symbol.ARCH == "mips64" or symbol.ARCH == "x86_64": + self.width = "{16}" + + self.register_line = re.compile("(([ ]*\\b(" + self.register_names[symbol.ARCH] + ")\\b +[0-9a-f]" + self.width + "){2,4})") + + # Note that both trace and value line matching allow for variable amounts of + # whitespace (e.g. \t). This is because the we want to allow for the stack + # tool to operate on AndroidFeedback provided system logs. AndroidFeedback + # strips out double spaces that are found in tombsone files and logcat output. + # + # Examples of matched trace lines include lines from tombstone files like: + # #00 pc 001cf42e /data/data/com.my.project/lib/libmyproject.so + # + # Or lines from AndroidFeedback crash report system logs like: + # 03-25 00:51:05.520 I/DEBUG ( 65): #00 pc 001cf42e /data/data/com.my.project/lib/libmyproject.so + # Please note the spacing differences. + self.trace_line = re.compile("(.*)\#([0-9]+)[ \t]+(..)[ \t]+([0-9a-f]" + self.width + ")[ \t]+([^\r\n \t]*)( \((.*)\))?") # pylint: disable-msg=C6310 + # Examples of matched value lines include: + # bea4170c 8018e4e9 /data/data/com.my.project/lib/libmyproject.so + # bea4170c 8018e4e9 /data/data/com.my.project/lib/libmyproject.so (symbol) + # 03-25 00:51:05.530 I/DEBUG ( 65): bea4170c 8018e4e9 /data/data/com.my.project/lib/libmyproject.so + # Again, note the spacing differences. + self.value_line = re.compile("(.*)([0-9a-f]" + self.width + ")[ \t]+([0-9a-f]" + self.width + ")[ \t]+([^\r\n \t]*)( \((.*)\))?") + # Lines from 'code around' sections of the output will be matched before + # value lines because otheriwse the 'code around' sections will be confused as + # value lines. + # + # Examples include: + # 801cf40c ffffc4cc 00b2f2c5 00b2f1c7 00c1e1a8 + # 03-25 00:51:05.530 I/DEBUG ( 65): 801cf40c ffffc4cc 00b2f2c5 00b2f1c7 00c1e1a8 + self.code_line = re.compile("(.*)[ \t]*[a-f0-9]" + self.width + + "[ \t]*[a-f0-9]" + self.width + + "[ \t]*[a-f0-9]" + self.width + + "[ \t]*[a-f0-9]" + self.width + + "[ \t]*[a-f0-9]" + self.width + + "[ \t]*[ \r\n]") # pylint: disable-msg=C6310 - for ln in lines: + def CleanLine(self, ln): # AndroidFeedback adds zero width spaces into its crash reports. These # should be removed or the regular expresssions will fail to match. - line = unicode(ln, errors='ignore') - process_header = process_info_line.search(line) - signal_header = signal_line.search(line) - register_header = register_line.search(line) - thread_header = thread_line.search(line) - dalvik_jni_thread_header = dalvik_jni_thread_line.search(line) - dalvik_native_thread_header = dalvik_native_thread_line.search(line) - if process_header or signal_header or register_header or thread_header \ - or dalvik_jni_thread_header or dalvik_native_thread_header: - if trace_lines or value_lines: - PrintOutput(trace_lines, value_lines) - PrintDivider() - trace_lines = [] - value_lines = [] - last_frame = -1 + return unicode(ln, errors='ignore') + + def PrintTraceLines(self, trace_lines): + """Print back trace.""" + maxlen = max(map(lambda tl: len(tl[1]), trace_lines)) + spacing = "" + if symbol.ARCH == "arm64" or symbol.ARCH == "mips64" or symbol.ARCH == "x86_64": + spacing = " " + print + print "Stack Trace:" + print " RELADDR " + spacing + "FUNCTION".ljust(maxlen) + " FILE:LINE" + for tl in self.trace_lines: + (addr, symbol_with_offset, location) = tl + print " %8s %s %s" % (addr, symbol_with_offset.ljust(maxlen), location) + return + + def PrintValueLines(self, value_lines): + """Print stack data values.""" + maxlen = max(map(lambda tl: len(tl[2]), self.value_lines)) + print + print "Stack Data:" + print " ADDR VALUE " + "FUNCTION".ljust(maxlen) + " FILE:LINE" + for vl in self.value_lines: + (addr, value, symbol_with_offset, location) = vl + print " %8s %8s %s %s" % (addr, value, symbol_with_offset.ljust(maxlen), location) + return + + def PrintOutput(self, trace_lines, value_lines): + if self.trace_lines: + self.PrintTraceLines(self.trace_lines) + if self.value_lines: + self.PrintValueLines(self.value_lines) + + def PrintDivider(self): + print + print "-----------------------------------------------------\n" + + def ConvertTrace(self, lines): + lines = map(self.CleanLine, lines) + for line in lines: + self.ProcessLine(line) + self.PrintOutput(self.trace_lines, self.value_lines) + + def ProcessLine(self, line): + process_header = self.process_info_line.search(line) + signal_header = self.signal_line.search(line) + abort_message_header = self.abort_message_line.search(line) + thread_header = self.thread_line.search(line) + register_header = self.register_line.search(line) + abi_header = self.abi_line.search(line) + dalvik_jni_thread_header = self.dalvik_jni_thread_line.search(line) + dalvik_native_thread_header = self.dalvik_native_thread_line.search(line) + if process_header or signal_header or abort_message_header or thread_header or abi_header or \ + register_header or dalvik_jni_thread_header or dalvik_native_thread_header: + if self.trace_lines or self.value_lines: + self.PrintOutput(self.trace_lines, self.value_lines) + self.PrintDivider() + self.trace_lines = [] + self.value_lines = [] + self.last_frame = -1 if process_header: print process_header.group(1) if signal_header: print signal_header.group(1) + if abort_message_header: + print abort_message_header.group(1) if register_header: print register_header.group(1) if thread_header: @@ -127,21 +167,25 @@ def ConvertTrace(lines): print dalvik_jni_thread_header.group(1) if dalvik_native_thread_header: print dalvik_native_thread_header.group(1) - continue - if trace_line.match(line): - match = trace_line.match(line) + if abi_header: + print abi_header.group(1) + symbol.ARCH = abi_header.group(2) + self.UpdateAbiRegexes() + return + if self.trace_line.match(line): + match = self.trace_line.match(line) (unused_0, frame, unused_1, code_addr, area, symbol_present, symbol_name) = match.groups() - if frame <= last_frame and (trace_lines or value_lines): - PrintOutput(trace_lines, value_lines) - PrintDivider() - trace_lines = [] - value_lines = [] - last_frame = frame + if frame <= self.last_frame and (self.trace_lines or self.value_lines): + self.PrintOutput(self.trace_lines, self.value_lines) + self.PrintDivider() + self.trace_lines = [] + self.value_lines = [] + self.last_frame = frame - if area == UNKNOWN or area == HEAP or area == STACK: - trace_lines.append((code_addr, "", area)) + if area == "<unknown>" or area == "[heap]" or area == "[stack]": + self.trace_lines.append((code_addr, "", area)) else: # If a calls b which further calls c and c is inlined to b, we want to # display "a -> b -> c" in the stack trace instead of just "a -> c" @@ -152,27 +196,30 @@ def ConvertTrace(lines): if symbol_present: source_symbol = symbol.CallCppFilt(symbol_name) else: - source_symbol = UNKNOWN + source_symbol = "<unknown>" if not source_location: source_location = area if nest_count > 0: nest_count = nest_count - 1 - trace_lines.append(("v------>", source_symbol, source_location)) + arrow = "v------>" + if symbol.ARCH == "arm64" or symbol.ARCH == "mips64" or symbol.ARCH == "x86_64": + arrow = "v-------------->" + self.trace_lines.append((arrow, source_symbol, source_location)) else: if not object_symbol_with_offset: object_symbol_with_offset = source_symbol - trace_lines.append((code_addr, + self.trace_lines.append((code_addr, object_symbol_with_offset, source_location)) - if code_line.match(line): + if self.code_line.match(line): # Code lines should be ignored. If this were exluded the 'code around' # sections would trigger value_line matches. - continue; - if value_line.match(line): - match = value_line.match(line) + return + if self.value_line.match(line): + match = self.value_line.match(line) (unused_, addr, value, area, symbol_present, symbol_name) = match.groups() - if area == UNKNOWN or area == HEAP or area == STACK or not area: - value_lines.append((addr, value, "", area)) + if area == "<unknown>" or area == "[heap]" or area == "[stack]" or not area: + self.value_lines.append((addr, value, "", area)) else: info = symbol.SymbolInformation(area, value) (source_symbol, source_location, object_symbol_with_offset) = info.pop() @@ -180,17 +227,190 @@ def ConvertTrace(lines): if symbol_present: source_symbol = symbol.CallCppFilt(symbol_name) else: - source_symbol = UNKNOWN + source_symbol = "<unknown>" if not source_location: source_location = area if not object_symbol_with_offset: object_symbol_with_offset = source_symbol - value_lines.append((addr, + self.value_lines.append((addr, value, object_symbol_with_offset, source_location)) - PrintOutput(trace_lines, value_lines) + #self.PrintOutput(self.trace_lines, self.value_lines) + + +example_arm_crash = """ +Build fingerprint: 'google/volantis/flounder:L/AAV73D/1227711:userdebug/dev-keys' +Revision: '0' +ABI: 'arm' +signal 6 (SIGABRT), code -6 (SI_TKILL), fault addr -------- + r0 00000000 r1 00002dd9 r2 00000006 r3 00000000 + r4 f710edd8 r5 00000006 r6 00000000 r7 0000010c + r8 f71b9df4 r9 ab0b5028 sl f7175695 fp f710edd0 + ip 00002dd9 sp f710ed18 lr f7175ef1 pc f719a4e0 cpsr 60070010 + d0 ffffffffffffffff d1 0000000000000031 + d2 0000000000000037 d3 0000000000000033 + d4 0000000000000000 d5 0000000000000000 + d6 0000000000000000 d7 0000000000000000 + d8 0000000000000000 d9 0000000000000000 + d10 0000000000000000 d11 0000000000000000 + d12 0000000000000000 d13 0000000000000000 + d14 0000000000000000 d15 0000000000000000 + d16 0000000000000000 d17 0000000000000fff + d18 0000000000000000 d19 0000000000000000 + d20 0000000000000000 d21 0000000000000000 + d22 0000000000000000 d23 0000000000000000 + d24 0000000000000000 d25 0000000000000000 + d26 0000000000000000 d27 0000000000000000 + d28 0000000000000000 d29 0000000000000000 + d30 0000000000000000 d31 0000000000000000 + scr 00000000 + +backtrace: + #00 pc 000374e0 /system/lib/libc.so (tgkill+12) + #01 pc 00012eed /system/lib/libc.so (pthread_kill+52) + #02 pc 00013997 /system/lib/libc.so (raise+10) + #03 pc 0001047d /system/lib/libc.so (__libc_android_abort+36) + #04 pc 0000eb1c /system/lib/libc.so (abort+4) + #05 pc 00000c6f /system/xbin/crasher + #06 pc 000126b3 /system/lib/libc.so (__pthread_start(void*)+30) + #07 pc 000107fb /system/lib/libc.so (__start_thread+6) +""" + +example_arm64_crash = """ +Build fingerprint: 'google/volantis/flounder:L/AAV73D/1227711:userdebug/dev-keys' +Revision: '0' +ABI: 'arm64' +signal 6 (SIGABRT), code -6 (SI_TKILL), fault addr -------- + x0 0000000000000000 x1 0000000000002df1 x2 0000000000000006 x3 000000559dc73040 + x4 ffffffffffffffff x5 0000000000000005 x6 0000000000000001 x7 0000000000000020 + x8 0000000000000083 x9 0000005563d21000 x10 0101010101010101 x11 0000000000000001 + x12 0000000000000001 x13 0000005563d21000 x14 0000005563d21000 x15 0000000000000000 + x16 0000005563d32f20 x17 0000000000000001 x18 0000000000000000 x19 000000559dc73040 + x20 0000007f844dcbb0 x21 0000007f84639000 x22 0000000000000000 x23 0000000000000006 + x24 0000007f845b2000 x25 0000007ff8f33bc0 x26 0000007f843df000 x27 000000559dc730c0 + x28 0000007f84639788 x29 0000007f844dc9c0 x30 0000007f845b38c4 + sp 0000007f844dc9c0 pc 0000007f845f28e0 + v0 2f2f2f2f2f2f2f2f v1 5f6474656e62696c v2 000000000000006f v3 0000000000000000 + v4 8020080280200800 v5 0000000000000000 v6 0000000000000000 v7 8020080280200802 + v8 0000000000000000 v9 0000000000000000 v10 0000000000000000 v11 0000000000000000 + v12 0000000000000000 v13 0000000000000000 v14 0000000000000000 v15 0000000000000000 + v16 4010040140100401 v17 0000aaa800000000 v18 8020080280200800 v19 0000000000000000 + v20 0000000000000000 v21 0000000000000000 v22 0000000000000000 v23 0000000000000000 + v24 0000000000000000 v25 0000000000000000 v26 0000000000000000 v27 0000000000000000 + v28 0000000000000000 v29 0000000000000000 v30 0000000000000000 v31 0000000000000000 + +backtrace: + #00 pc 00000000000588e0 /system/lib64/libc.so (tgkill+8) + #01 pc 00000000000198c0 /system/lib64/libc.so (pthread_kill+160) + #02 pc 000000000001ab34 /system/lib64/libc.so (raise+28) + #03 pc 00000000000148bc /system/lib64/libc.so (abort+60) + #04 pc 00000000000016e0 /system/xbin/crasher64 + #05 pc 00000000000017f0 /system/xbin/crasher64 + #06 pc 0000000000018958 /system/lib64/libc.so (__pthread_start(void*)+52) + #07 pc 0000000000014e90 /system/lib64/libc.so (__start_thread+16) +""" + +example_mips_crash = """ +Build fingerprint: 'Android/aosp_mips/generic_mips:4.4.3.43.43.43/AOSP/enh06302258:eng/test-keys' +Revision: '0' +ABI: 'mips' +pid: 958, tid: 960, name: crasher >>> crasher <<< +signal 6 (SIGABRT), code -6 (SI_TKILL), fault addr -------- + zr 00000000 at 802babc0 v0 00000000 v1 77b99dd0 + a0 000003be a1 000003c0 a2 00000006 a3 00000000 + t0 00000000 t1 9e7f5440 t2 00000020 t3 ffffff18 + t4 77a9c000 t5 00000001 t6 00000000 t7 00000000 + s0 000003c0 s1 77b99dd8 s2 00000000 s3 00000006 + s4 77db2028 s5 000003be s6 77c39fa8 s7 77b99dd0 + t8 00000000 t9 77c89e80 k0 00000000 k1 00000000 + gp 77cce350 sp 77b99c78 s8 77db2020 ra 77c3b48c + hi 00000000 lo 00000008 bva 7fff7008 epc 77c89e94 + +backtrace: + #00 pc 00067e94 /system/lib/libc.so (tgkill+20) + #01 pc 0001948c /system/lib/libc.so (pthread_kill+244) + #02 pc 0001b0e8 /system/lib/libc.so (raise+60) + #03 pc 00012908 /system/lib/libc.so (abort+104) + #04 pc 000012a4 /system/xbin/crasher + #05 pc 00018008 /system/lib/libc.so (__pthread_start(void*)+96) + #06 pc 00013198 /system/lib/libc.so (__start_thread+36) +""" + +example_x86_crash = """ +Build fingerprint: 'Android/aosp_x86_64/generic_x86_64:4.4.3.43.43.43/AOSP/enh06301456:eng/test-keys' +Revision: '0' +ABI: 'x86' +pid: 1566, tid: 1568, name: crasher >>> crasher <<< +signal 6 (SIGABRT), code -6 (SI_TKILL), fault addr -------- + eax 00000000 ebx 0000061e ecx 00000620 edx 00000006 + esi f7679dd8 edi 00000000 + xcs 00000023 xds 0000002b xes 0000002b xfs 00000003 xss 0000002b + eip f7758ea6 ebp 00000620 esp f7679c60 flags 00000282 + +backtrace: + #00 pc 00076ea6 /system/lib/libc.so (tgkill+22) + #01 pc 0001dc8b /system/lib/libc.so (pthread_kill+155) + #02 pc 0001f294 /system/lib/libc.so (raise+36) + #03 pc 00017a04 /system/lib/libc.so (abort+84) + #04 pc 00001099 /system/xbin/crasher + #05 pc 0001cd58 /system/lib/libc.so (__pthread_start(void*)+56) + #06 pc 00018169 /system/lib/libc.so (__start_thread+25) + #07 pc 0000ed76 /system/lib/libc.so (__bionic_clone+70) +""" + +example_x86_64_crash = """ +Build fingerprint: 'Android/aosp_x86_64/generic_x86_64:4.4.3.43.43.43/AOSP/enh06301456:eng/test-keys' +Revision: '0' +ABI: 'x86_64' +pid: 1608, tid: 1610, name: crasher64 >>> crasher64 <<< +signal 6 (SIGABRT), code -6 (SI_TKILL), fault addr -------- + rax 0000000000000000 rbx 000000000000064a rcx ffffffffffffffff rdx 0000000000000006 + rsi 000000000000064a rdi 0000000000000648 + r8 0000000000000001 r9 00007fe218110c98 r10 0000000000000008 r11 0000000000000206 + r12 0000000000000000 r13 0000000000000006 r14 00007fe218111ba0 r15 0000000000000648 + cs 0000000000000033 ss 000000000000002b + rip 00007fe218201807 rbp 00007fe218111bb0 rsp 00007fe218111a18 eflags 0000000000000206 + +backtrace: + #00 pc 0000000000077807 /system/lib64/libc.so (tgkill+7) + #01 pc 000000000002243f /system/lib64/libc.so (pthread_kill+143) + #02 pc 0000000000023551 /system/lib64/libc.so (raise+17) + #03 pc 000000000001ce6d /system/lib64/libc.so (abort+61) + #04 pc 0000000000001385 /system/xbin/crasher64 + #05 pc 00000000000014a8 /system/xbin/crasher64 + #06 pc 00000000000215ae /system/lib64/libc.so (__pthread_start(void*)+46) + #07 pc 000000000001d3eb /system/lib64/libc.so (__start_thread+11) + #08 pc 00000000000138f5 /system/lib64/libc.so (__bionic_clone+53) +""" + + +class RegisterPatternTests(unittest.TestCase): + def assert_register_matches(self, abi, example_crash, stupid_pattern): + tc = TraceConverter() + symbol.ARCH = abi + tc.UpdateAbiRegexes() + for line in example_crash.split('\n'): + is_register = (re.search(stupid_pattern, line) is not None) + matched = (tc.register_line.search(line) is not None) + self.assertEquals(matched, is_register, line) + + def test_arm_registers(self): + self.assert_register_matches("arm", example_arm_crash, '\\b(r0|r4|r8|ip)\\b') + + def test_arm64_registers(self): + self.assert_register_matches("arm64", example_arm64_crash, '\\b(x0|x4|x8|x12|x16|x20|x24|x28|sp)\\b') + + def test_mips_registers(self): + self.assert_register_matches("mips", example_mips_crash, '\\b(zr|a0|t0|t4|s0|s4|t8|gp|hi)\\b') + + def test_x86_registers(self): + self.assert_register_matches("x86", example_x86_crash, '\\b(eax|esi|xcs|eip)\\b') + + def test_x86_64_registers(self): + self.assert_register_matches("x86_64", example_x86_64_crash, '\\b(rax|rsi|r8|r12|cs|rip)\\b') -# vi: ts=2 sw=2 +if __name__ == '__main__': + unittest.main() |