| #!/usr/bin/perl |
| |
| use strict; |
| |
| #---------------------------------------------------------------------- |
| # Globals |
| #---------------------------------------------------------------------- |
| our $unimplemented_str = "UNIMPLEMENTED"; |
| our $success_str = "OK"; |
| our $swap = 1; |
| our $addr_size = 4; |
| our $thread_suffix_supported = 0; |
| our $max_bytes_per_line = 32; |
| our $addr_format = sprintf("0x%%%u.%ux", $addr_size*2, $addr_size*2); |
| our $pid_format = "%04.4x"; |
| our $tid_format = "%04.4x"; |
| our $reg8_href = { extract => \&get8, format => "0x%2.2x" }; |
| our $reg16_href = { extract => \&get16, format => "0x%4.4x" }; |
| our $reg32_href = { extract => \&get32, format => "0x%8.8x" }; |
| our $reg64_href = { extract => \&get64, format => "0x%s" }; |
| our $reg80_href = { extract => \&get80, format => "0x%s" }; |
| our $reg128_href = { extract => \&get128, format => "0x%s" }; |
| our $reg256_href = { extract => \&get256, format => "0x%s" }; |
| our $float32_href = { extract => \&get32, format => "0x%8.8x" }; |
| our $float64_href = { extract => \&get64, format => "0x%s" }; |
| our $float96_href = { extract => \&get96, format => "0x%s" }; |
| our $curr_cmd = undef; |
| our $curr_full_cmd = undef; |
| our %packet_times; |
| our $curr_time = 0.0; |
| our $last_time = 0.0; |
| our $base_time = 0.0; |
| our $packet_start_time = 0.0; |
| our $reg_cmd_reg; |
| our %reg_map = ( |
| 'i386-gdb' => [ |
| { name => 'eax', info => $reg32_href }, |
| { name => 'ecx', info => $reg32_href }, |
| { name => 'edx', info => $reg32_href }, |
| { name => 'ebx', info => $reg32_href }, |
| { name => 'esp', info => $reg32_href }, |
| { name => 'ebp', info => $reg32_href }, |
| { name => 'esi', info => $reg32_href }, |
| { name => 'edi', info => $reg32_href }, |
| { name => 'eip', info => $reg32_href }, |
| { name => 'eflags', info => $reg32_href }, |
| { name => 'cs', info => $reg32_href }, |
| { name => 'ss', info => $reg32_href }, |
| { name => 'ds', info => $reg32_href }, |
| { name => 'es', info => $reg32_href }, |
| { name => 'fs', info => $reg32_href }, |
| { name => 'gs', info => $reg32_href }, |
| { name => 'st0', info => $reg80_href }, |
| { name => 'st1', info => $reg80_href }, |
| { name => 'st2', info => $reg80_href }, |
| { name => 'st3', info => $reg80_href }, |
| { name => 'st4', info => $reg80_href }, |
| { name => 'st5', info => $reg80_href }, |
| { name => 'st6', info => $reg80_href }, |
| { name => 'st7', info => $reg80_href }, |
| { name => 'fctrl', info => $reg32_href }, |
| { name => 'fstat', info => $reg32_href }, |
| { name => 'ftag', info => $reg32_href }, |
| { name => 'fiseg', info => $reg32_href }, |
| { name => 'fioff', info => $reg32_href }, |
| { name => 'foseg', info => $reg32_href }, |
| { name => 'fooff', info => $reg32_href }, |
| { name => 'fop', info => $reg32_href }, |
| { name => 'xmm0', info => $reg128_href }, |
| { name => 'xmm1', info => $reg128_href }, |
| { name => 'xmm2', info => $reg128_href }, |
| { name => 'xmm3', info => $reg128_href }, |
| { name => 'xmm4', info => $reg128_href }, |
| { name => 'xmm5', info => $reg128_href }, |
| { name => 'xmm6', info => $reg128_href }, |
| { name => 'xmm7', info => $reg128_href }, |
| { name => 'mxcsr', info => $reg32_href }, |
| { name => 'mm0', info => $reg64_href }, |
| { name => 'mm1', info => $reg64_href }, |
| { name => 'mm2', info => $reg64_href }, |
| { name => 'mm3', info => $reg64_href }, |
| { name => 'mm4', info => $reg64_href }, |
| { name => 'mm5', info => $reg64_href }, |
| { name => 'mm6', info => $reg64_href }, |
| { name => 'mm7', info => $reg64_href }, |
| ], |
| |
| 'i386-lldb' => [ |
| { name => 'eax', info => $reg32_href }, |
| { name => 'ebx', info => $reg32_href }, |
| { name => 'ecx', info => $reg32_href }, |
| { name => 'edx', info => $reg32_href }, |
| { name => 'edi', info => $reg32_href }, |
| { name => 'esi', info => $reg32_href }, |
| { name => 'ebp', info => $reg32_href }, |
| { name => 'esp', info => $reg32_href }, |
| { name => 'ss', info => $reg32_href }, |
| { name => 'eflags', info => $reg32_href }, |
| { name => 'eip', info => $reg32_href }, |
| { name => 'cs', info => $reg32_href }, |
| { name => 'ds', info => $reg32_href }, |
| { name => 'es', info => $reg32_href }, |
| { name => 'fs', info => $reg32_href }, |
| { name => 'gs', info => $reg32_href }, |
| { name => 'fctrl', info => $reg16_href }, |
| { name => 'fstat', info => $reg16_href }, |
| { name => 'ftag', info => $reg8_href }, |
| { name => 'fop', info => $reg16_href }, |
| { name => 'fioff', info => $reg32_href }, |
| { name => 'fiseg', info => $reg16_href }, |
| { name => 'fooff', info => $reg32_href }, |
| { name => 'foseg', info => $reg16_href }, |
| { name => 'mxcsr', info => $reg32_href }, |
| { name => 'mxcsrmask', info => $reg32_href }, |
| { name => 'stmm0', info => $reg80_href }, |
| { name => 'stmm1', info => $reg80_href }, |
| { name => 'stmm2', info => $reg80_href }, |
| { name => 'stmm3', info => $reg80_href }, |
| { name => 'stmm4', info => $reg80_href }, |
| { name => 'stmm5', info => $reg80_href }, |
| { name => 'stmm6', info => $reg80_href }, |
| { name => 'stmm7', info => $reg80_href }, |
| { name => 'xmm0', info => $reg128_href }, |
| { name => 'xmm1', info => $reg128_href }, |
| { name => 'xmm2', info => $reg128_href }, |
| { name => 'xmm3', info => $reg128_href }, |
| { name => 'xmm4', info => $reg128_href }, |
| { name => 'xmm5', info => $reg128_href }, |
| { name => 'xmm6', info => $reg128_href }, |
| { name => 'xmm7', info => $reg128_href }, |
| { name => 'trapno', info => $reg32_href }, |
| { name => 'err', info => $reg32_href }, |
| { name => 'faultvaddr', info => $reg32_href }, |
| ], |
| |
| 'arm-gdb' => [ |
| { name => 'r0' , info => $reg32_href }, |
| { name => 'r1' , info => $reg32_href }, |
| { name => 'r2' , info => $reg32_href }, |
| { name => 'r3' , info => $reg32_href }, |
| { name => 'r4' , info => $reg32_href }, |
| { name => 'r5' , info => $reg32_href }, |
| { name => 'r6' , info => $reg32_href }, |
| { name => 'r7' , info => $reg32_href }, |
| { name => 'r8' , info => $reg32_href }, |
| { name => 'r9' , info => $reg32_href }, |
| { name => 'r10' , info => $reg32_href }, |
| { name => 'r11' , info => $reg32_href }, |
| { name => 'r12' , info => $reg32_href }, |
| { name => 'sp' , info => $reg32_href }, |
| { name => 'lr' , info => $reg32_href }, |
| { name => 'pc' , info => $reg32_href }, |
| { name => 'f0' , info => $float96_href }, |
| { name => 'f1' , info => $float96_href }, |
| { name => 'f2' , info => $float96_href }, |
| { name => 'f3' , info => $float96_href }, |
| { name => 'f4' , info => $float96_href }, |
| { name => 'f5' , info => $float96_href }, |
| { name => 'f6' , info => $float96_href }, |
| { name => 'f7' , info => $float96_href }, |
| { name => 'fps' , info => $reg32_href }, |
| { name => 'cpsr' , info => $reg32_href }, |
| { name => 's0' , info => $float32_href }, |
| { name => 's1' , info => $float32_href }, |
| { name => 's2' , info => $float32_href }, |
| { name => 's3' , info => $float32_href }, |
| { name => 's4' , info => $float32_href }, |
| { name => 's5' , info => $float32_href }, |
| { name => 's6' , info => $float32_href }, |
| { name => 's7' , info => $float32_href }, |
| { name => 's8' , info => $float32_href }, |
| { name => 's9' , info => $float32_href }, |
| { name => 's10' , info => $float32_href }, |
| { name => 's11' , info => $float32_href }, |
| { name => 's12' , info => $float32_href }, |
| { name => 's13' , info => $float32_href }, |
| { name => 's14' , info => $float32_href }, |
| { name => 's15' , info => $float32_href }, |
| { name => 's16' , info => $float32_href }, |
| { name => 's17' , info => $float32_href }, |
| { name => 's18' , info => $float32_href }, |
| { name => 's19' , info => $float32_href }, |
| { name => 's20' , info => $float32_href }, |
| { name => 's21' , info => $float32_href }, |
| { name => 's22' , info => $float32_href }, |
| { name => 's23' , info => $float32_href }, |
| { name => 's24' , info => $float32_href }, |
| { name => 's25' , info => $float32_href }, |
| { name => 's26' , info => $float32_href }, |
| { name => 's27' , info => $float32_href }, |
| { name => 's28' , info => $float32_href }, |
| { name => 's29' , info => $float32_href }, |
| { name => 's30' , info => $float32_href }, |
| { name => 's31' , info => $float32_href }, |
| { name => 'fpscr' , info => $reg32_href }, |
| { name => 'd16' , info => $float64_href }, |
| { name => 'd17' , info => $float64_href }, |
| { name => 'd18' , info => $float64_href }, |
| { name => 'd19' , info => $float64_href }, |
| { name => 'd20' , info => $float64_href }, |
| { name => 'd21' , info => $float64_href }, |
| { name => 'd22' , info => $float64_href }, |
| { name => 'd23' , info => $float64_href }, |
| { name => 'd24' , info => $float64_href }, |
| { name => 'd25' , info => $float64_href }, |
| { name => 'd26' , info => $float64_href }, |
| { name => 'd27' , info => $float64_href }, |
| { name => 'd28' , info => $float64_href }, |
| { name => 'd29' , info => $float64_href }, |
| { name => 'd30' , info => $float64_href }, |
| { name => 'd31' , info => $float64_href }, |
| ], |
| |
| |
| 'arm-lldb' => [ |
| { name => 'r0' , info => $reg32_href }, |
| { name => 'r1' , info => $reg32_href }, |
| { name => 'r2' , info => $reg32_href }, |
| { name => 'r3' , info => $reg32_href }, |
| { name => 'r4' , info => $reg32_href }, |
| { name => 'r5' , info => $reg32_href }, |
| { name => 'r6' , info => $reg32_href }, |
| { name => 'r7' , info => $reg32_href }, |
| { name => 'r8' , info => $reg32_href }, |
| { name => 'r9' , info => $reg32_href }, |
| { name => 'r10' , info => $reg32_href }, |
| { name => 'r11' , info => $reg32_href }, |
| { name => 'r12' , info => $reg32_href }, |
| { name => 'sp' , info => $reg32_href }, |
| { name => 'lr' , info => $reg32_href }, |
| { name => 'pc' , info => $reg32_href }, |
| { name => 'cpsr' , info => $reg32_href }, |
| { name => 's0' , info => $float32_href }, |
| { name => 's1' , info => $float32_href }, |
| { name => 's2' , info => $float32_href }, |
| { name => 's3' , info => $float32_href }, |
| { name => 's4' , info => $float32_href }, |
| { name => 's5' , info => $float32_href }, |
| { name => 's6' , info => $float32_href }, |
| { name => 's7' , info => $float32_href }, |
| { name => 's8' , info => $float32_href }, |
| { name => 's9' , info => $float32_href }, |
| { name => 's10' , info => $float32_href }, |
| { name => 's11' , info => $float32_href }, |
| { name => 's12' , info => $float32_href }, |
| { name => 's13' , info => $float32_href }, |
| { name => 's14' , info => $float32_href }, |
| { name => 's15' , info => $float32_href }, |
| { name => 's16' , info => $float32_href }, |
| { name => 's17' , info => $float32_href }, |
| { name => 's18' , info => $float32_href }, |
| { name => 's19' , info => $float32_href }, |
| { name => 's20' , info => $float32_href }, |
| { name => 's21' , info => $float32_href }, |
| { name => 's22' , info => $float32_href }, |
| { name => 's23' , info => $float32_href }, |
| { name => 's24' , info => $float32_href }, |
| { name => 's25' , info => $float32_href }, |
| { name => 's26' , info => $float32_href }, |
| { name => 's27' , info => $float32_href }, |
| { name => 's28' , info => $float32_href }, |
| { name => 's29' , info => $float32_href }, |
| { name => 's30' , info => $float32_href }, |
| { name => 's31' , info => $float32_href }, |
| { name => 'd0' , info => $float64_href }, |
| { name => 'd1' , info => $float64_href }, |
| { name => 'd2' , info => $float64_href }, |
| { name => 'd3' , info => $float64_href }, |
| { name => 'd4' , info => $float64_href }, |
| { name => 'd5' , info => $float64_href }, |
| { name => 'd6' , info => $float64_href }, |
| { name => 'd7' , info => $float64_href }, |
| { name => 'd8' , info => $float64_href }, |
| { name => 'd9' , info => $float64_href }, |
| { name => 'd10' , info => $float64_href }, |
| { name => 'd11' , info => $float64_href }, |
| { name => 'd12' , info => $float64_href }, |
| { name => 'd13' , info => $float64_href }, |
| { name => 'd14' , info => $float64_href }, |
| { name => 'd15' , info => $float64_href }, |
| { name => 'd16' , info => $float64_href }, |
| { name => 'd17' , info => $float64_href }, |
| { name => 'd18' , info => $float64_href }, |
| { name => 'd19' , info => $float64_href }, |
| { name => 'd20' , info => $float64_href }, |
| { name => 'd21' , info => $float64_href }, |
| { name => 'd22' , info => $float64_href }, |
| { name => 'd23' , info => $float64_href }, |
| { name => 'd24' , info => $float64_href }, |
| { name => 'd25' , info => $float64_href }, |
| { name => 'd26' , info => $float64_href }, |
| { name => 'd27' , info => $float64_href }, |
| { name => 'd28' , info => $float64_href }, |
| { name => 'd29' , info => $float64_href }, |
| { name => 'd30' , info => $float64_href }, |
| { name => 'd31' , info => $float64_href }, |
| { name => 'fpscr' , info => $reg32_href }, |
| { name => 'exc' , info => $reg32_href }, |
| { name => 'fsr' , info => $reg32_href }, |
| { name => 'far' , info => $reg32_href }, |
| ], |
| |
| 'x86_64-gdb' => [ |
| { name => 'rax' , info => $reg64_href }, |
| { name => 'rbx' , info => $reg64_href }, |
| { name => 'rcx' , info => $reg64_href }, |
| { name => 'rdx' , info => $reg64_href }, |
| { name => 'rsi' , info => $reg64_href }, |
| { name => 'rdi' , info => $reg64_href }, |
| { name => 'rbp' , info => $reg64_href }, |
| { name => 'rsp' , info => $reg64_href }, |
| { name => 'r8' , info => $reg64_href }, |
| { name => 'r9' , info => $reg64_href }, |
| { name => 'r10' , info => $reg64_href }, |
| { name => 'r11' , info => $reg64_href }, |
| { name => 'r12' , info => $reg64_href }, |
| { name => 'r13' , info => $reg64_href }, |
| { name => 'r14' , info => $reg64_href }, |
| { name => 'r15' , info => $reg64_href }, |
| { name => 'rip' , info => $reg64_href }, |
| { name => 'eflags' , info => $reg32_href }, |
| { name => 'cs' , info => $reg32_href }, |
| { name => 'ss' , info => $reg32_href }, |
| { name => 'ds' , info => $reg32_href }, |
| { name => 'es' , info => $reg32_href }, |
| { name => 'fs' , info => $reg32_href }, |
| { name => 'gs' , info => $reg32_href }, |
| { name => 'stmm0' , info => $reg80_href }, |
| { name => 'stmm1' , info => $reg80_href }, |
| { name => 'stmm2' , info => $reg80_href }, |
| { name => 'stmm3' , info => $reg80_href }, |
| { name => 'stmm4' , info => $reg80_href }, |
| { name => 'stmm5' , info => $reg80_href }, |
| { name => 'stmm6' , info => $reg80_href }, |
| { name => 'stmm7' , info => $reg80_href }, |
| { name => 'fctrl' , info => $reg32_href }, |
| { name => 'fstat' , info => $reg32_href }, |
| { name => 'ftag' , info => $reg32_href }, |
| { name => 'fiseg' , info => $reg32_href }, |
| { name => 'fioff' , info => $reg32_href }, |
| { name => 'foseg' , info => $reg32_href }, |
| { name => 'fooff' , info => $reg32_href }, |
| { name => 'fop' , info => $reg32_href }, |
| { name => 'xmm0' , info => $reg128_href }, |
| { name => 'xmm1' , info => $reg128_href }, |
| { name => 'xmm2' , info => $reg128_href }, |
| { name => 'xmm3' , info => $reg128_href }, |
| { name => 'xmm4' , info => $reg128_href }, |
| { name => 'xmm5' , info => $reg128_href }, |
| { name => 'xmm6' , info => $reg128_href }, |
| { name => 'xmm7' , info => $reg128_href }, |
| { name => 'xmm8' , info => $reg128_href }, |
| { name => 'xmm9' , info => $reg128_href }, |
| { name => 'xmm10' , info => $reg128_href }, |
| { name => 'xmm11' , info => $reg128_href }, |
| { name => 'xmm12' , info => $reg128_href }, |
| { name => 'xmm13' , info => $reg128_href }, |
| { name => 'xmm14' , info => $reg128_href }, |
| { name => 'xmm15' , info => $reg128_href }, |
| { name => 'mxcsr' , info => $reg32_href }, |
| ], |
| |
| 'x86_64-lldb' => [ |
| { name => 'rax' , info => $reg64_href }, |
| { name => 'rbx' , info => $reg64_href }, |
| { name => 'rcx' , info => $reg64_href }, |
| { name => 'rdx' , info => $reg64_href }, |
| { name => 'rdi' , info => $reg64_href }, |
| { name => 'rsi' , info => $reg64_href }, |
| { name => 'rbp' , info => $reg64_href }, |
| { name => 'rsp' , info => $reg64_href }, |
| { name => 'r8 ' , info => $reg64_href }, |
| { name => 'r9 ' , info => $reg64_href }, |
| { name => 'r10' , info => $reg64_href }, |
| { name => 'r11' , info => $reg64_href }, |
| { name => 'r12' , info => $reg64_href }, |
| { name => 'r13' , info => $reg64_href }, |
| { name => 'r14' , info => $reg64_href }, |
| { name => 'r15' , info => $reg64_href }, |
| { name => 'rip' , info => $reg64_href }, |
| { name => 'rflags' , info => $reg64_href }, |
| { name => 'cs' , info => $reg64_href }, |
| { name => 'fs' , info => $reg64_href }, |
| { name => 'gs' , info => $reg64_href }, |
| { name => 'fctrl' , info => $reg16_href }, |
| { name => 'fstat' , info => $reg16_href }, |
| { name => 'ftag' , info => $reg8_href }, |
| { name => 'fop' , info => $reg16_href }, |
| { name => 'fioff' , info => $reg32_href }, |
| { name => 'fiseg' , info => $reg16_href }, |
| { name => 'fooff' , info => $reg32_href }, |
| { name => 'foseg' , info => $reg16_href }, |
| { name => 'mxcsr' , info => $reg32_href }, |
| { name => 'mxcsrmask' , info => $reg32_href }, |
| { name => 'stmm0' , info => $reg80_href }, |
| { name => 'stmm1' , info => $reg80_href }, |
| { name => 'stmm2' , info => $reg80_href }, |
| { name => 'stmm3' , info => $reg80_href }, |
| { name => 'stmm4' , info => $reg80_href }, |
| { name => 'stmm5' , info => $reg80_href }, |
| { name => 'stmm6' , info => $reg80_href }, |
| { name => 'stmm7' , info => $reg80_href }, |
| { name => 'xmm0' , info => $reg128_href }, |
| { name => 'xmm1' , info => $reg128_href }, |
| { name => 'xmm2' , info => $reg128_href }, |
| { name => 'xmm3' , info => $reg128_href }, |
| { name => 'xmm4' , info => $reg128_href }, |
| { name => 'xmm5' , info => $reg128_href }, |
| { name => 'xmm6' , info => $reg128_href }, |
| { name => 'xmm7' , info => $reg128_href }, |
| { name => 'xmm8' , info => $reg128_href }, |
| { name => 'xmm9' , info => $reg128_href }, |
| { name => 'xmm10' , info => $reg128_href }, |
| { name => 'xmm11' , info => $reg128_href }, |
| { name => 'xmm12' , info => $reg128_href }, |
| { name => 'xmm13' , info => $reg128_href }, |
| { name => 'xmm14' , info => $reg128_href }, |
| { name => 'xmm15' , info => $reg128_href }, |
| { name => 'trapno' , info => $reg32_href }, |
| { name => 'err' , info => $reg32_href }, |
| { name => 'faultvaddr' , info => $reg64_href }, |
| ] |
| ); |
| |
| our $max_register_name_len = 0; |
| calculate_max_register_name_length(); |
| our @point_types = ( "software_bp", "hardware_bp", "write_wp", "read_wp", "access_wp" ); |
| our $opt_v = 0; # verbose |
| our $opt_g = 0; # debug |
| our $opt_q = 0; # quiet |
| our $opt_r = undef; |
| use Getopt::Std; |
| getopts('gvqr:'); |
| |
| our $registers_aref = undef; |
| |
| if (length($opt_r)) |
| { |
| if (exists $reg_map{$opt_r}) |
| { |
| $registers_aref = $reg_map{$opt_r}; |
| } |
| else |
| { |
| die "Can't get registers group for '$opt_r'\n"; |
| } |
| } |
| |
| sub extract_key_value_pairs |
| { |
| my $kv_href = {}; |
| my $arrayref = shift; |
| my $str = join('',@$arrayref); |
| my @kv_strs = split(/;/, $str); |
| foreach my $kv_str (@kv_strs) |
| { |
| my ($key, $value) = split(/:/, $kv_str); |
| $kv_href->{$key} = $value; |
| } |
| return $kv_href; |
| } |
| |
| sub get_thread_from_thread_suffix |
| { |
| if ($thread_suffix_supported) |
| { |
| my $arrayref = shift; |
| # Skip leading semi-colon if needed |
| $$arrayref[0] == ';' and shift @$arrayref; |
| my $thread_href = extract_key_value_pairs ($arrayref); |
| if (exists $thread_href->{thread}) |
| { |
| return $thread_href->{thread}; |
| } |
| } |
| return undef; |
| } |
| |
| sub calculate_max_register_name_length |
| { |
| $max_register_name_len = 7; |
| foreach my $reg_href (@$registers_aref) |
| { |
| my $name_len = length($reg_href->{name}); |
| if ($max_register_name_len < $name_len) |
| { |
| $max_register_name_len = $name_len; |
| } |
| } |
| } |
| #---------------------------------------------------------------------- |
| # Hash that maps command characters to the appropriate functions using |
| # the command character as the key and the value being a reference to |
| # the dump function for dumping the command itself. |
| #---------------------------------------------------------------------- |
| our %cmd_callbacks = |
| ( |
| '?' => \&dump_last_signal_cmd, |
| 'H' => \&dump_set_thread_cmd, |
| 'T' => \&dump_thread_is_alive_cmd, |
| 'q' => \&dump_general_query_cmd, |
| 'Q' => \&dump_general_set_cmd, |
| 'g' => \&dump_read_regs_cmd, |
| 'G' => \&dump_write_regs_cmd, |
| 'p' => \&dump_read_single_register_cmd, |
| 'P' => \&dump_write_single_register_cmd, |
| 'm' => \&dump_read_mem_cmd, |
| 'M' => \&dump_write_mem_cmd, |
| 'X' => \&dump_write_mem_binary_cmd, |
| 'Z' => \&dump_bp_wp_command, |
| 'z' => \&dump_bp_wp_command, |
| 'k' => \&dump_kill_cmd, |
| 'A' => \&dump_A_command, |
| 'c' => \&dump_continue_cmd, |
| 's' => \&dump_continue_cmd, |
| 'C' => \&dump_continue_with_signal_cmd, |
| 'S' => \&dump_continue_with_signal_cmd, |
| '_M' => \&dump_allocate_memory_cmd, |
| '_m' => \&dump_deallocate_memory_cmd, |
| # extended commands |
| 'v' => \&dump_extended_cmd |
| ); |
| |
| #---------------------------------------------------------------------- |
| # Hash that maps command characters to the appropriate functions using |
| # the command character as the key and the value being a reference to |
| # the dump function for the response to the command. |
| #---------------------------------------------------------------------- |
| our %rsp_callbacks = |
| ( |
| 'c' => \&dump_stop_reply_packet, |
| 's' => \&dump_stop_reply_packet, |
| 'C' => \&dump_stop_reply_packet, |
| '?' => \&dump_stop_reply_packet, |
| 'T' => \&dump_thread_is_alive_rsp, |
| 'H' => \&dump_set_thread_rsp, |
| 'q' => \&dump_general_query_rsp, |
| 'g' => \&dump_read_regs_rsp, |
| 'p' => \&dump_read_single_register_rsp, |
| 'm' => \&dump_read_mem_rsp, |
| '_M' => \&dump_allocate_memory_rsp, |
| |
| # extended commands |
| 'v' => \&dump_extended_rsp, |
| ); |
| |
| |
| sub dump_register_value |
| { |
| my $indent = shift; |
| my $arrayref = shift; |
| my $reg_num = shift; |
| |
| if ($reg_num >= @$registers_aref) |
| { |
| printf("\tinvalid register index %d\n", $reg_num); |
| return; |
| } |
| |
| my $reg_href = $$registers_aref[$reg_num]; |
| my $reg_name = $reg_href->{name}; |
| if ($$arrayref[0] eq '#') |
| { |
| printf("\t%*s: error: EOS reached when trying to read register %d\n", $max_register_name_len, $reg_name, $reg_num); |
| } |
| |
| my $reg_info = $reg_href->{info}; |
| my $reg_extract = $reg_info->{extract}; |
| my $reg_format = $reg_info->{format}; |
| my $reg_val = &$reg_extract($arrayref); |
| if ($indent) { |
| printf("\t%*s = $reg_format", $max_register_name_len, $reg_name, $reg_val); |
| } else { |
| printf("%s = $reg_format", $reg_name, $reg_val); |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # Extract the command into an array of ASCII char strings for easy |
| # processing |
| #---------------------------------------------------------------------- |
| sub extract_command |
| { |
| my $cmd_str = shift; |
| my @cmd_chars = split(/ */, $cmd_str); |
| if ($cmd_chars[0] ne '$') |
| { |
| # only set the current command if it isn't a reply |
| $curr_cmd = $cmd_chars[0]; |
| } |
| return @cmd_chars; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Strip the 3 checksum array entries after we don't need them anymore |
| #---------------------------------------------------------------------- |
| sub strip_checksum |
| { |
| my $arrayref = shift; |
| splice(@$arrayref, -3); |
| } |
| |
| #---------------------------------------------------------------------- |
| # Dump all strings in array by joining them together with no space |
| # between them |
| #---------------------------------------------------------------------- |
| sub dump_chars |
| { |
| print join('',@_); |
| } |
| |
| #---------------------------------------------------------------------- |
| # Check if the response is an error 'EXX' |
| #---------------------------------------------------------------------- |
| sub is_error_response |
| { |
| if ($_[0] eq 'E') |
| { |
| shift; |
| print "ERROR = " . join('',@_) . "\n"; |
| return 1; |
| } |
| return 0; |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'H' command |
| #---------------------------------------------------------------------- |
| sub dump_set_thread_cmd |
| { |
| my $cmd = shift; |
| my $mod = shift; |
| print "set_thread ( $mod, " . join('',@_) . " )\n"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'T' command |
| #---------------------------------------------------------------------- |
| our $T_cmd_tid = -1; |
| sub dump_thread_is_alive_cmd |
| { |
| my $cmd = shift; |
| $T_cmd_tid = get_hex(\@_); |
| printf("thread_is_alive ( $tid_format )\n", $T_cmd_tid); |
| } |
| |
| sub dump_thread_is_alive_rsp |
| { |
| my $rsp = join('',@_); |
| |
| printf("thread_is_alive ( $tid_format ) =>", $T_cmd_tid); |
| if ($rsp eq 'OK') |
| { |
| print " alive.\n"; |
| } |
| else |
| { |
| print " dead.\n"; |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'H' response |
| #---------------------------------------------------------------------- |
| sub dump_set_thread_rsp |
| { |
| if (!is_error_response(@_)) |
| { |
| print join('',@_) . "\n"; |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'q' command |
| #---------------------------------------------------------------------- |
| our $gen_query_cmd; |
| our $qRegisterInfo_reg_num = -1; |
| sub dump_general_query_cmd |
| { |
| $gen_query_cmd = join('',@_); |
| if ($gen_query_cmd eq 'qC') |
| { |
| print 'get_current_pid ()'; |
| } |
| elsif ($gen_query_cmd eq 'qfThreadInfo') |
| { |
| print 'get_first_active_threads ()'; |
| } |
| elsif ($gen_query_cmd eq 'qsThreadInfo') |
| { |
| print 'get_subsequent_active_threads ()'; |
| } |
| elsif (index($gen_query_cmd, 'qThreadExtraInfo') == 0) |
| { |
| # qThreadExtraInfo,id |
| print 'get_thread_extra_info ()'; |
| } |
| elsif (index($gen_query_cmd, 'qThreadStopInfo') == 0) |
| { |
| # qThreadStopInfoXXXX |
| @_ = splice(@_, length('qThreadStopInfo')); |
| my $tid = get_addr(\@_); |
| printf('get_thread_stop_info ( thread = 0x%4.4x )', $tid); |
| } |
| elsif (index($gen_query_cmd, 'qSymbol:') == 0) |
| { |
| # qCRC:addr,length |
| print 'gdb_ready_to_serve_symbol_lookups ()'; |
| } |
| elsif (index($gen_query_cmd, 'qCRC:') == 0) |
| { |
| # qCRC:addr,length |
| @_ = splice(@_, length('qCRC:')); |
| my $address = get_addr(\@_); |
| shift @_; |
| my $length = join('', @_); |
| printf("compute_crc (addr = $addr_format, length = $length)", $address); |
| } |
| elsif (index($gen_query_cmd, 'qGetTLSAddr:') == 0) |
| { |
| # qGetTLSAddr:thread-id,offset,lm |
| @_ = splice(@_, length('qGetTLSAddr:')); |
| my ($tid, $offset, $lm) = split (/,/, join('', @_)); |
| print "get_thread_local_storage_addr (thread-id = $tid, offset = $offset, lm = $lm)"; |
| } |
| elsif ($gen_query_cmd eq 'qOffsets') |
| { |
| print 'get_section_offsets ()'; |
| } |
| elsif (index($gen_query_cmd, 'qRegisterInfo') == 0) |
| { |
| @_ = splice(@_, length('qRegisterInfo')); |
| $qRegisterInfo_reg_num = get_hex(\@_); |
| |
| printf "get_dynamic_register_info ($qRegisterInfo_reg_num)"; |
| } |
| else |
| { |
| print $gen_query_cmd; |
| } |
| print "\n"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'q' response |
| #---------------------------------------------------------------------- |
| sub dump_general_query_rsp |
| { |
| my $gen_query_rsp = join('',@_); |
| my $gen_query_rsp_len = length ($gen_query_rsp); |
| if ($gen_query_cmd eq 'qC' and index($gen_query_rsp, 'QC') == 0) |
| { |
| shift @_; shift @_; |
| my $pid = get_hex(\@_); |
| printf("pid = $pid_format\n", $pid); |
| return; |
| } |
| elsif (index($gen_query_cmd, 'qRegisterInfo') == 0) |
| { |
| if ($gen_query_rsp_len == 0) |
| { |
| print "$unimplemented_str\n"; |
| } |
| else |
| { |
| if (index($gen_query_rsp, 'name') == 0) |
| { |
| $qRegisterInfo_reg_num == 0 and $registers_aref = []; |
| |
| my @name_and_values = split (/;/, $gen_query_rsp); |
| |
| my $reg_name = undef; |
| my $byte_size = 0; |
| my $pseudo = 0; |
| foreach (@name_and_values) |
| { |
| my ($name, $value) = split /:/; |
| if ($name eq "name") { $reg_name = $value; } |
| elsif ($name eq "bitsize") { $byte_size = $value / 8; } |
| elsif ($name eq "container-regs") { $pseudo = 1; } |
| } |
| if (defined $reg_name and $byte_size > 0) |
| { |
| if ($byte_size == 4) {push @$registers_aref, { name => $reg_name, info => $reg32_href , pseudo => $pseudo };} |
| elsif ($byte_size == 8) {push @$registers_aref, { name => $reg_name, info => $reg64_href , pseudo => $pseudo };} |
| elsif ($byte_size == 1) {push @$registers_aref, { name => $reg_name, info => $reg8_href , pseudo => $pseudo };} |
| elsif ($byte_size == 2) {push @$registers_aref, { name => $reg_name, info => $reg16_href , pseudo => $pseudo };} |
| elsif ($byte_size == 10) {push @$registers_aref, { name => $reg_name, info => $reg80_href , pseudo => $pseudo };} |
| elsif ($byte_size == 12) {push @$registers_aref, { name => $reg_name, info => $float96_href , pseudo => $pseudo };} |
| elsif ($byte_size == 16) {push @$registers_aref, { name => $reg_name, info => $reg128_href , pseudo => $pseudo };} |
| elsif ($byte_size == 32) {push @$registers_aref, { name => $reg_name, info => $reg256_href , pseudo => $pseudo };} |
| } |
| } |
| elsif ($gen_query_rsp_len == 3 and index($gen_query_rsp, 'E') == 0) |
| { |
| calculate_max_register_name_length(); |
| } |
| } |
| } |
| elsif ($gen_query_cmd =~ 'qThreadStopInfo') |
| { |
| dump_stop_reply_packet (@_); |
| } |
| if (dump_standard_response(\@_)) |
| { |
| # Do nothing... |
| } |
| else |
| { |
| print join('',@_) . "\n"; |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'Q' command |
| #---------------------------------------------------------------------- |
| our $gen_set_cmd; |
| sub dump_general_set_cmd |
| { |
| $gen_query_cmd = join('',@_); |
| if ($gen_query_cmd eq 'QStartNoAckMode') |
| { |
| print "StartNoAckMode ()" |
| } |
| elsif ($gen_query_cmd eq 'QThreadSuffixSupported') |
| { |
| $thread_suffix_supported = 1; |
| print "ThreadSuffixSupported ()" |
| } |
| elsif (index($gen_query_cmd, 'QSetMaxPayloadSize:') == 0) |
| { |
| @_ = splice(@_, length('QSetMaxPayloadSize:')); |
| my $max_payload_size = get_hex(\@_); |
| # QSetMaxPayloadSize:XXXX where XXXX is a hex length of the max |
| # packet payload size supported by gdb |
| printf("SetMaxPayloadSize ( 0x%x (%u))", $max_payload_size, $max_payload_size); |
| } |
| elsif (index ($gen_query_cmd, 'QSetSTDIN:') == 0) |
| { |
| @_ = splice(@_, length('QSetSTDIN:')); |
| printf ("SetSTDIN (path ='%s')\n", get_hex_string (\@_)); |
| } |
| elsif (index ($gen_query_cmd, 'QSetSTDOUT:') == 0) |
| { |
| @_ = splice(@_, length('QSetSTDOUT:')); |
| printf ("SetSTDOUT (path ='%s')\n", get_hex_string (\@_)); |
| } |
| elsif (index ($gen_query_cmd, 'QSetSTDERR:') == 0) |
| { |
| @_ = splice(@_, length('QSetSTDERR:')); |
| printf ("SetSTDERR (path ='%s')\n", get_hex_string (\@_)); |
| } |
| else |
| { |
| print $gen_query_cmd; |
| } |
| print "\n"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'k' command |
| #---------------------------------------------------------------------- |
| sub dump_kill_cmd |
| { |
| my $cmd = shift; |
| print "kill (" . join('',@_) . ")\n"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'g' command |
| #---------------------------------------------------------------------- |
| sub dump_read_regs_cmd |
| { |
| my $cmd = shift; |
| print "read_registers ()\n"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'G' command |
| #---------------------------------------------------------------------- |
| sub dump_write_regs_cmd |
| { |
| print "write_registers:\n"; |
| my $cmd = shift; |
| foreach my $reg_href (@$registers_aref) |
| { |
| last if ($_[0] eq '#'); |
| if ($reg_href->{pseudo} == 0) |
| { |
| my $reg_info_href = $reg_href->{info}; |
| my $reg_name = $reg_href->{name}; |
| my $reg_extract = $reg_info_href->{extract}; |
| my $reg_format = $reg_info_href->{format}; |
| my $reg_val = &$reg_extract(\@_); |
| printf("\t%*s = $reg_format\n", $max_register_name_len, $reg_name, $reg_val); |
| } |
| } |
| } |
| |
| sub dump_read_regs_rsp |
| { |
| print "read_registers () =>\n"; |
| if (!is_error_response(@_)) |
| { |
| # print join('',@_) . "\n"; |
| foreach my $reg_href (@$registers_aref) |
| { |
| last if ($_[0] eq '#'); |
| if ($reg_href->{pseudo} == 0) |
| { |
| my $reg_info_href = $reg_href->{info}; |
| my $reg_name = $reg_href->{name}; |
| my $reg_extract = $reg_info_href->{extract}; |
| my $reg_format = $reg_info_href->{format}; |
| my $reg_val = &$reg_extract(\@_); |
| printf("\t%*s = $reg_format\n", $max_register_name_len, $reg_name, $reg_val); |
| } |
| } |
| } |
| } |
| |
| sub dump_read_single_register_rsp |
| { |
| dump_register_value(0, \@_, $reg_cmd_reg); |
| print "\n"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # '_M' - allocate memory command (LLDB extension) |
| # |
| # Command: '_M' |
| # Arg1: Hex byte size as big endian hex string |
| # Separator: ',' |
| # Arg2: permissions as string that must be a string that contains any |
| # combination of 'r' (readable) 'w' (writable) or 'x' (executable) |
| # |
| # Returns: The address that was allocated as a big endian hex string |
| # on success, else an error "EXX" where XX are hex bytes |
| # that indicate an error code. |
| # |
| # Examples: |
| # _M10,rw # allocate 16 bytes with read + write permissions |
| # _M100,rx # allocate 256 bytes with read + execute permissions |
| #---------------------------------------------------------------------- |
| sub dump_allocate_memory_cmd |
| { |
| shift; shift; # shift off the '_' and the 'M' |
| my $byte_size = get_addr(\@_); |
| shift; # Skip ',' |
| printf("allocate_memory ( byte_size = %u (0x%x), permissions = %s)\n", $byte_size, $byte_size, join('',@_)); |
| } |
| |
| sub dump_allocate_memory_rsp |
| { |
| if (@_ == 3 and $_[0] == 'E') |
| { |
| printf("allocated memory addr = ERROR (%s))\n", join('',@_)); |
| } |
| else |
| { |
| printf("allocated memory addr = 0x%s\n", join('',@_)); |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # '_m' - deallocate memory command (LLDB extension) |
| # |
| # Command: '_m' |
| # Arg1: Hex address as big endian hex string |
| # |
| # Returns: "OK" on success "EXX" on error |
| # |
| # Examples: |
| # _m201000 # Free previously allocated memory at address 0x201000 |
| #---------------------------------------------------------------------- |
| sub dump_deallocate_memory_cmd |
| { |
| shift; shift; # shift off the '_' and the 'm' |
| printf("deallocate_memory ( addr = 0x%s)\n", join('',@_)); |
| } |
| |
| |
| #---------------------------------------------------------------------- |
| # 'p' command |
| #---------------------------------------------------------------------- |
| sub dump_read_single_register_cmd |
| { |
| my $cmd = shift; |
| $reg_cmd_reg = get_hex(\@_); |
| my $thread = get_thread_from_thread_suffix (\@_); |
| my $reg_href = $$registers_aref[$reg_cmd_reg]; |
| |
| if (defined $thread) |
| { |
| print "read_register ( reg = \"$reg_href->{name}\", thread = $thread )\n"; |
| } |
| else |
| { |
| print "read_register ( reg = \"$reg_href->{name}\" )\n"; |
| } |
| } |
| |
| |
| #---------------------------------------------------------------------- |
| # 'P' command |
| #---------------------------------------------------------------------- |
| sub dump_write_single_register_cmd |
| { |
| my $cmd = shift; |
| my $reg_num = get_hex(\@_); |
| shift (@_); # Discard the '=' |
| |
| print "write_register ( "; |
| dump_register_value(0, \@_, $reg_num); |
| my $thread = get_thread_from_thread_suffix (\@_); |
| if (defined $thread) |
| { |
| print ", thread = $thread"; |
| } |
| print " )\n"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'm' command |
| #---------------------------------------------------------------------- |
| our $read_mem_address = 0; |
| sub dump_read_mem_cmd |
| { |
| my $cmd = shift; |
| $read_mem_address = get_addr(\@_); |
| shift; # Skip ',' |
| printf("read_mem ( $addr_format, %s )\n", $read_mem_address, join('',@_)); |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'm' response |
| #---------------------------------------------------------------------- |
| sub dump_read_mem_rsp |
| { |
| # If the memory read was 2 or 4 bytes, print it out in native format |
| # instead of just as bytes. |
| my $num_nibbles = @_; |
| if ($num_nibbles == 2) |
| { |
| printf(" 0x%2.2x", get8(\@_)); |
| } |
| elsif ($num_nibbles == 4) |
| { |
| printf(" 0x%4.4x", get16(\@_)); |
| } |
| elsif ($num_nibbles == 8) |
| { |
| printf(" 0x%8.8x", get32(\@_)); |
| } |
| elsif ($num_nibbles == 16) |
| { |
| printf(" 0x%s", get64(\@_)); |
| } |
| else |
| { |
| my $curr_address = $read_mem_address; |
| my $nibble; |
| my $nibble_offset = 0; |
| my $max_nibbles_per_line = 2 * $max_bytes_per_line; |
| foreach $nibble (@_) |
| { |
| if (($nibble_offset % $max_nibbles_per_line) == 0) |
| { |
| ($nibble_offset > 0) and print "\n "; |
| printf("$addr_format: ", $curr_address + $nibble_offset/2); |
| } |
| (($nibble_offset % 2) == 0) and print ' '; |
| print $nibble; |
| $nibble_offset++; |
| } |
| } |
| print "\n"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'c' or 's' command |
| #---------------------------------------------------------------------- |
| sub dump_continue_cmd |
| { |
| my $cmd = shift; |
| my $cmd_str; |
| $cmd eq 'c' and $cmd_str = 'continue'; |
| $cmd eq 's' and $cmd_str = 'step'; |
| my $address = -1; |
| if (@_) |
| { |
| my $address = get_addr(\@_); |
| printf("%s ($addr_format)\n", $cmd_str, $address); |
| } |
| else |
| { |
| printf("%s ()\n", $cmd_str); |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'Css' continue (C) with signal (ss where 'ss' is two hex digits) |
| # 'Sss' step (S) with signal (ss where 'ss' is two hex digits) |
| #---------------------------------------------------------------------- |
| sub dump_continue_with_signal_cmd |
| { |
| my $cmd = shift; |
| my $address = -1; |
| my $cmd_str; |
| $cmd eq 'c' and $cmd_str = 'continue'; |
| $cmd eq 's' and $cmd_str = 'step'; |
| my $signal = get_hex(\@_); |
| if (@_) |
| { |
| my $address = 0; |
| if (@_ && $_[0] == ';') |
| { |
| shift; |
| $address = get_addr(\@_); |
| } |
| } |
| |
| if ($address != -1) |
| { |
| printf("%s_with_signal (signal = 0x%2.2x, address = $addr_format)\n", $cmd_str, $signal, $address); |
| } |
| else |
| { |
| printf("%s_with_signal (signal = 0x%2.2x)\n", $cmd_str, $signal); |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'A' command |
| #---------------------------------------------------------------------- |
| sub dump_A_command |
| { |
| my $cmd = get_expected_char(\@_, 'A') or print "error: incorrect command letter for argument packet, expected 'A'\n"; |
| printf("set_program_arguments (\n"); |
| do |
| { |
| my $arg_len = get_uint(\@_); |
| get_expected_char(\@_, ',') or die "error: missing comma after argument length...?\n"; |
| my $arg_idx = get_uint(\@_); |
| get_expected_char(\@_, ',') or die "error: missing comma after argument number...?\n"; |
| |
| my $arg = ''; |
| my $num_hex8_bytes = $arg_len/2; |
| for (1 .. $num_hex8_bytes) |
| { |
| $arg .= sprintf("%c", get8(\@_)) |
| } |
| printf(" <%3u> argv[%u] = '%s'\n", $arg_len, $arg_idx, $arg); |
| if (@_ > 0) |
| { |
| get_expected_char(\@_, ',') or die "error: missing comma after argument argument ASCII hex bytes...?\n"; |
| } |
| } while (@_ > 0); |
| printf(" )\n"); |
| } |
| |
| |
| #---------------------------------------------------------------------- |
| # 'z' and 'Z' command |
| #---------------------------------------------------------------------- |
| sub dump_bp_wp_command |
| { |
| my $cmd = shift; |
| my $type = shift; |
| shift; # Skip ',' |
| my $address = get_addr(\@_); |
| shift; # Skip ',' |
| my $length = join('',@_); |
| if ($cmd eq 'z') |
| { |
| printf("remove $point_types[$type]($addr_format, %d)\n", $address, $length); |
| } |
| else |
| { |
| printf("insert $point_types[$type]($addr_format, %d)\n", $address, $length); |
| } |
| } |
| |
| |
| #---------------------------------------------------------------------- |
| # 'X' command |
| #---------------------------------------------------------------------- |
| sub dump_write_mem_binary_cmd |
| { |
| my $cmd = shift; |
| my $address = get_addr(\@_); |
| shift; # Skip ',' |
| |
| my ($length, $binary) = split(/:/, join('',@_)); |
| printf("write_mem_binary ( $addr_format, %d, %s)\n", $address, $length, $binary); |
| |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'M' command |
| #---------------------------------------------------------------------- |
| sub dump_write_mem_cmd |
| { |
| my $cmd = shift; |
| my $address = get_addr(\@_); |
| shift; # Skip ',' |
| my ($length, $hex_bytes) = split(/:/, join('',@_)); |
| # printf("write_mem ( $addr_format, %d, %s)\n", $address, $length, $hex_bytes); |
| printf("write_mem ( addr = $addr_format, len = %d (0x%x), bytes = ", $address, $length, $length); |
| splice(@_, 0, length($length)+1); |
| |
| my $curr_address = $address; |
| my $nibble; |
| my $nibble_count = 0; |
| my $max_nibbles_per_line = 2 * $max_bytes_per_line; |
| foreach $nibble (@_) |
| { |
| (($nibble_count % 2) == 0) and print ' '; |
| print $nibble; |
| $nibble_count++; |
| } |
| |
| # If the memory to write is 2 or 4 bytes, print it out in native format |
| # instead of just as bytes. |
| if (@_ == 4) |
| { |
| printf(" ( 0x%4.4x )", get16(\@_)); |
| } |
| elsif (@_ == 8) |
| { |
| printf(" ( 0x%8.8x )", get32(\@_)); |
| } |
| print " )\n"; |
| |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'v' command |
| #---------------------------------------------------------------------- |
| our $extended_rsp_callback = 0; |
| sub dump_extended_cmd |
| { |
| $extended_rsp_callback = 0; |
| if (join('', @_[0..4]) eq "vCont") |
| { |
| dump_extended_continue_cmd(splice(@_,5)); |
| } |
| elsif (join('', @_[0..7]) eq 'vAttach;') |
| { |
| dump_attach_command (splice(@_,8)); |
| } |
| elsif (join('', @_[0..11]) eq 'vAttachWait;') |
| { |
| dump_attach_wait_command (splice(@_,12)); |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'v' response |
| #---------------------------------------------------------------------- |
| sub dump_extended_rsp |
| { |
| if ($extended_rsp_callback) |
| { |
| &$extended_rsp_callback(@_); |
| } |
| $extended_rsp_callback = 0; |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'vAttachWait' command |
| #---------------------------------------------------------------------- |
| sub dump_attach_wait_command |
| { |
| print "attach_wait ( "; |
| while (@_) |
| { |
| printf("%c", get8(\@_)) |
| } |
| printf " )\n"; |
| |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'vAttach' command |
| #---------------------------------------------------------------------- |
| sub dump_attach_command |
| { |
| printf("attach ( pid = %i )", get_hex(\@_)); |
| $extended_rsp_callback = \&dump_stop_reply_packet; |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'vCont' command |
| #---------------------------------------------------------------------- |
| sub dump_extended_continue_cmd |
| { |
| print "extended_continue ( "; |
| my $cmd = shift; |
| if ($cmd eq '?') |
| { |
| print "list supported modes )\n"; |
| $extended_rsp_callback = \&dump_extended_continue_rsp; |
| } |
| elsif ($cmd eq ';') |
| { |
| $extended_rsp_callback = \&dump_stop_reply_packet; |
| my $i = 0; |
| while ($#_ >= 0) |
| { |
| if ($i > 0) |
| { |
| print ", "; |
| } |
| my $continue_cmd = shift; |
| my $tmp; |
| if ($continue_cmd eq 'c') |
| { |
| print "continue"; |
| } |
| elsif ($continue_cmd eq 'C') |
| { |
| print "continue with signal "; |
| print shift; |
| print shift; |
| } |
| elsif ($continue_cmd eq 's') |
| { |
| print "step"; |
| } |
| elsif ($continue_cmd eq 'S') |
| { |
| print "step with signal "; |
| print shift; |
| print shift; |
| } |
| |
| if ($_[0] eq ':') |
| { |
| shift; # Skip ':' |
| print " for thread "; |
| while ($#_ >= 0) |
| { |
| $tmp = shift; |
| if (length($tmp) > 0 && $tmp ne ';') { |
| print $tmp; |
| } else { |
| last; |
| } |
| } |
| } |
| $i++; |
| } |
| |
| printf " )\n"; |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # 'vCont' response |
| #---------------------------------------------------------------------- |
| sub dump_extended_continue_rsp |
| { |
| if (scalar(@_) == 0) |
| { |
| print "$unimplemented_str\n"; |
| } |
| else |
| { |
| print "extended_continue supports " . join('',@_) . "\n"; |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # Dump the command ascii for any unknown commands |
| #---------------------------------------------------------------------- |
| sub dump_other_cmd |
| { |
| print "other = " . join('',@_) . "\n"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Check to see if the response was unsupported with appropriate checksum |
| #---------------------------------------------------------------------- |
| sub rsp_is_unsupported |
| { |
| return join('',@_) eq "#00"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Check to see if the response was "OK" with appropriate checksum |
| #---------------------------------------------------------------------- |
| sub rsp_is_OK |
| { |
| return join('',@_) eq "OK#9a"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Dump a response for an unknown command |
| #---------------------------------------------------------------------- |
| sub dump_other_rsp |
| { |
| print "other = " . join('',@_) . "\n"; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Get a byte from the ascii string assuming that the 2 nibble ascii |
| # characters are in hex. |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it (no leading # "0x") |
| #---------------------------------------------------------------------- |
| sub get8 |
| { |
| my $arrayref = shift; |
| my $val = hex(shift(@$arrayref) . shift(@$arrayref)); |
| return $val; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Get a 16 bit integer and swap if $swap global is set to a non-zero |
| # value. |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it (no leading # "0x") |
| #---------------------------------------------------------------------- |
| sub get16 |
| { |
| my $arrayref = shift; |
| my $val = 0; |
| if ($swap) |
| { |
| $val = get8($arrayref) | |
| get8($arrayref) << 8; |
| } |
| else |
| { |
| $val = get8($arrayref) << 8 | |
| get8($arrayref) ; |
| } |
| return $val; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Get a 32 bit integer and swap if $swap global is set to a non-zero |
| # value. |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it (no leading # "0x") |
| #---------------------------------------------------------------------- |
| sub get32 |
| { |
| my $arrayref = shift; |
| my $val = 0; |
| if ($swap) |
| { |
| $val = get8($arrayref) | |
| get8($arrayref) << 8 | |
| get8($arrayref) << 16 | |
| get8($arrayref) << 24 ; |
| } |
| else |
| { |
| $val = get8($arrayref) << 24 | |
| get8($arrayref) << 16 | |
| get8($arrayref) << 8 | |
| get8($arrayref) ; |
| } |
| return $val; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Get a 64 bit hex value as a string |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it (no leading # "0x") |
| #---------------------------------------------------------------------- |
| sub get64 |
| { |
| my $arrayref = shift; |
| my $val = ''; |
| my @nibbles; |
| if ($swap) |
| { |
| push @nibbles, splice(@$arrayref, 14, 2); |
| push @nibbles, splice(@$arrayref, 12, 2); |
| push @nibbles, splice(@$arrayref, 10, 2); |
| push @nibbles, splice(@$arrayref, 8, 2); |
| push @nibbles, splice(@$arrayref, 6, 2); |
| push @nibbles, splice(@$arrayref, 4, 2); |
| push @nibbles, splice(@$arrayref, 2, 2); |
| push @nibbles, splice(@$arrayref, 0, 2); |
| } |
| else |
| { |
| (@nibbles) = splice(@$arrayref, 0, ((64/8) * 2)); |
| } |
| $val = join('', @nibbles); |
| return $val; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Get a 80 bit hex value as a string |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it (no leading # "0x") |
| #---------------------------------------------------------------------- |
| sub get80 |
| { |
| my $arrayref = shift; |
| my $val = ''; |
| my @nibbles; |
| if ($swap) |
| { |
| push @nibbles, splice(@$arrayref, 18, 2); |
| push @nibbles, splice(@$arrayref, 16, 2); |
| push @nibbles, splice(@$arrayref, 14, 2); |
| push @nibbles, splice(@$arrayref, 12, 2); |
| push @nibbles, splice(@$arrayref, 10, 2); |
| push @nibbles, splice(@$arrayref, 8, 2); |
| push @nibbles, splice(@$arrayref, 6, 2); |
| push @nibbles, splice(@$arrayref, 4, 2); |
| push @nibbles, splice(@$arrayref, 2, 2); |
| push @nibbles, splice(@$arrayref, 0, 2); |
| } |
| else |
| { |
| (@nibbles) = splice(@$arrayref, 0, ((80/8) * 2)); |
| } |
| $val = join('', @nibbles); |
| return $val; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Get a 96 bit hex value as a string |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it (no leading # "0x") |
| #---------------------------------------------------------------------- |
| sub get96 |
| { |
| my $arrayref = shift; |
| my $val = ''; |
| my @nibbles; |
| if ($swap) |
| { |
| push @nibbles, splice(@$arrayref, 22, 2); |
| push @nibbles, splice(@$arrayref, 20, 2); |
| push @nibbles, splice(@$arrayref, 18, 2); |
| push @nibbles, splice(@$arrayref, 16, 2); |
| push @nibbles, splice(@$arrayref, 14, 2); |
| push @nibbles, splice(@$arrayref, 12, 2); |
| push @nibbles, splice(@$arrayref, 10, 2); |
| push @nibbles, splice(@$arrayref, 8, 2); |
| push @nibbles, splice(@$arrayref, 6, 2); |
| push @nibbles, splice(@$arrayref, 4, 2); |
| push @nibbles, splice(@$arrayref, 2, 2); |
| push @nibbles, splice(@$arrayref, 0, 2); |
| } |
| else |
| { |
| (@nibbles) = splice(@$arrayref, 0, ((96/8) * 2)); |
| } |
| $val = join('', @nibbles); |
| return $val; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Get a 128 bit hex value as a string |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it (no leading # "0x") |
| #---------------------------------------------------------------------- |
| sub get128 |
| { |
| my $arrayref = shift; |
| my $val = ''; |
| my @nibbles; |
| if ($swap) |
| { |
| push @nibbles, splice(@$arrayref, 30, 2); |
| push @nibbles, splice(@$arrayref, 28, 2); |
| push @nibbles, splice(@$arrayref, 26, 2); |
| push @nibbles, splice(@$arrayref, 24, 2); |
| push @nibbles, splice(@$arrayref, 22, 2); |
| push @nibbles, splice(@$arrayref, 20, 2); |
| push @nibbles, splice(@$arrayref, 18, 2); |
| push @nibbles, splice(@$arrayref, 16, 2); |
| push @nibbles, splice(@$arrayref, 14, 2); |
| push @nibbles, splice(@$arrayref, 12, 2); |
| push @nibbles, splice(@$arrayref, 10, 2); |
| push @nibbles, splice(@$arrayref, 8, 2); |
| push @nibbles, splice(@$arrayref, 6, 2); |
| push @nibbles, splice(@$arrayref, 4, 2); |
| push @nibbles, splice(@$arrayref, 2, 2); |
| push @nibbles, splice(@$arrayref, 0, 2); |
| } |
| else |
| { |
| (@nibbles) = splice(@$arrayref, 0, ((128/8) * 2)); |
| } |
| $val = join('', @nibbles); |
| return $val; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Get a 256 bit hex value as a string |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it (no leading # "0x") |
| #---------------------------------------------------------------------- |
| sub get256 |
| { |
| my $arrayref = shift; |
| my $val = ''; |
| my @nibbles; |
| if ($swap) |
| { |
| push @nibbles, splice(@$arrayref, 62, 2); |
| push @nibbles, splice(@$arrayref, 60, 2); |
| push @nibbles, splice(@$arrayref, 58, 2); |
| push @nibbles, splice(@$arrayref, 56, 2); |
| push @nibbles, splice(@$arrayref, 54, 2); |
| push @nibbles, splice(@$arrayref, 52, 2); |
| push @nibbles, splice(@$arrayref, 50, 2); |
| push @nibbles, splice(@$arrayref, 48, 2); |
| push @nibbles, splice(@$arrayref, 46, 2); |
| push @nibbles, splice(@$arrayref, 44, 2); |
| push @nibbles, splice(@$arrayref, 42, 2); |
| push @nibbles, splice(@$arrayref, 40, 2); |
| push @nibbles, splice(@$arrayref, 38, 2); |
| push @nibbles, splice(@$arrayref, 36, 2); |
| push @nibbles, splice(@$arrayref, 34, 2); |
| push @nibbles, splice(@$arrayref, 32, 2); |
| push @nibbles, splice(@$arrayref, 30, 2); |
| push @nibbles, splice(@$arrayref, 28, 2); |
| push @nibbles, splice(@$arrayref, 26, 2); |
| push @nibbles, splice(@$arrayref, 24, 2); |
| push @nibbles, splice(@$arrayref, 22, 2); |
| push @nibbles, splice(@$arrayref, 20, 2); |
| push @nibbles, splice(@$arrayref, 18, 2); |
| push @nibbles, splice(@$arrayref, 16, 2); |
| push @nibbles, splice(@$arrayref, 14, 2); |
| push @nibbles, splice(@$arrayref, 12, 2); |
| push @nibbles, splice(@$arrayref, 10, 2); |
| push @nibbles, splice(@$arrayref, 8, 2); |
| push @nibbles, splice(@$arrayref, 6, 2); |
| push @nibbles, splice(@$arrayref, 4, 2); |
| push @nibbles, splice(@$arrayref, 2, 2); |
| push @nibbles, splice(@$arrayref, 0, 2); |
| } |
| else |
| { |
| (@nibbles) = splice(@$arrayref, 0, ((256/8) * 2)); |
| } |
| $val = join('', @nibbles); |
| return $val; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Get an unsigned integer value by grabbing items off the front of |
| # the array stopping when a non-digit char string is encountered. |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it |
| #---------------------------------------------------------------------- |
| sub get_uint |
| { |
| my $arrayref = shift; |
| @$arrayref == 0 and return 0; |
| my $val = 0; |
| while ($$arrayref[0] =~ /[0-9]/) |
| { |
| $val = $val * 10 + int(shift(@$arrayref)); |
| } |
| return $val; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Check the first character in the array and if it matches the expected |
| # character, return that character, else return undef; |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it. If the expected |
| # character doesn't match, it won't touch the array. If the first |
| # character does match, it will shift it off and return it. |
| #---------------------------------------------------------------------- |
| sub get_expected_char |
| { |
| my $arrayref = shift; |
| my $expected_char = shift; |
| if ($expected_char eq $$arrayref[0]) |
| { |
| return shift(@$arrayref); |
| } |
| return undef; |
| } |
| #---------------------------------------------------------------------- |
| # Get a hex value by grabbing items off the front of the array and |
| # stopping when a non-hex char string is encountered. |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it (no leading # "0x") |
| #---------------------------------------------------------------------- |
| sub get_hex |
| { |
| my $arrayref = shift; |
| my $my_swap = @_ ? shift : 0; |
| my $shift = 0; |
| my $val = 0; |
| while ($$arrayref[0] =~ /[0-9a-fA-F]/) |
| { |
| if ($my_swap) |
| { |
| my $byte = hex(shift(@$arrayref)) << 4 | hex(shift(@$arrayref)); |
| $val |= $byte << $shift; |
| $shift += 8; |
| } |
| else |
| { |
| $val <<= 4; |
| $val |= hex(shift(@$arrayref)); |
| } |
| } |
| return $val; |
| } |
| |
| #---------------------------------------------------------------------- |
| # Get an address value by grabbing items off the front of the array. |
| # |
| # The argument for this function needs to be a reference to an array |
| # that contains single character strings and the array will get |
| # updated by shifting characters off the front of it (no leading # "0x") |
| #---------------------------------------------------------------------- |
| sub get_addr |
| { |
| get_hex(shift); |
| } |
| |
| sub get_hex_string |
| { |
| my $arrayref = shift; |
| my $str = ''; |
| while ($$arrayref[0] =~ /[0-9a-fA-F]/ and $$arrayref[1] =~ /[0-9a-fA-F]/) |
| { |
| my $hi_nibble = hex(shift(@$arrayref)); |
| my $lo_nibble = hex(shift(@$arrayref)); |
| my $byte = ($hi_nibble << 4) | $lo_nibble; |
| $str .= chr($byte); |
| } |
| return $str; |
| } |
| |
| sub dump_stop_reply_data |
| { |
| while ($#_ >= 0) |
| { |
| last unless ($_[0] ne '#'); |
| |
| |
| my $key = ''; |
| my $value = ''; |
| my $comment = ''; |
| if ($_[0] =~ /[0-9a-fA-F]/ && $_[1] =~ /[0-9a-fA-F]/) |
| { |
| my $reg_num = get8(\@_); |
| shift(@_); # Skip ':' |
| if (defined ($registers_aref) && $reg_num < @$registers_aref) |
| { |
| dump_register_value(1, \@_, $reg_num); |
| print "\n"; |
| shift(@_); # Skip ';' |
| next; |
| } |
| $key = sprintf("reg %u", $reg_num); |
| } |
| my $char; |
| |
| if (length($key) == 0) |
| { |
| while (1) |
| { |
| $char = shift(@_); |
| if (length($char) == 0 or $char eq ':' or $char eq '#') { last; } |
| $key .= $char; |
| } |
| } |
| |
| while (1) |
| { |
| $char = shift(@_); |
| if (length($char) == 0 or $char eq ';' or $char eq '#') { last; } |
| $value .= $char; |
| } |
| if ($key eq 'metype') |
| { |
| our %metype_to_name = ( |
| '1' => ' (EXC_BAD_ACCESS)', |
| '2' => ' (EXC_BAD_INSTRUCTION)', |
| '3' => ' (EXC_ARITHMETIC)', |
| '4' => ' (EXC_EMULATION)', |
| '5' => ' (EXC_SOFTWARE)', |
| '6' => ' (EXC_BREAKPOINT)', |
| '7' => ' (EXC_SYSCALL)', |
| '8' => ' (EXC_MACH_SYSCALL)', |
| '9' => ' (EXC_RPC_ALERT)', |
| '10' => ' (EXC_CRASH)' |
| ); |
| if (exists $metype_to_name{$value}) |
| { |
| $comment = $metype_to_name{$value}; |
| } |
| } |
| printf("\t%*s = %s$comment\n", $max_register_name_len, $key, $value); |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # Dumps a Stop Reply Packet which happens in response to a step, |
| # continue, last signal, and probably a few other commands. |
| #---------------------------------------------------------------------- |
| sub dump_stop_reply_packet |
| { |
| my $what = shift(@_); |
| if ($what eq 'S' or $what eq 'T') |
| { |
| my $signo = get8(\@_); |
| |
| our %signo_to_name = ( |
| '1' => ' SIGHUP', |
| '2' => ' SIGINT', |
| '3' => ' SIGQUIT', |
| '4' => ' SIGILL', |
| '5' => ' SIGTRAP', |
| '6' => ' SIGABRT', |
| '7' => ' SIGPOLL/SIGEMT', |
| '8' => ' SIGFPE', |
| '9' => ' SIGKILL', |
| '10' => ' SIGBUS', |
| '11' => ' SIGSEGV', |
| '12' => ' SIGSYS', |
| '13' => ' SIGPIPE', |
| '14' => ' SIGALRM', |
| '15' => ' SIGTERM', |
| '16' => ' SIGURG', |
| '17' => ' SIGSTOP', |
| '18' => ' SIGTSTP', |
| '19' => ' SIGCONT', |
| '20' => ' SIGCHLD', |
| '21' => ' SIGTTIN', |
| '22' => ' SIGTTOU', |
| '23' => ' SIGIO', |
| '24' => ' SIGXCPU', |
| '25' => ' SIGXFSZ', |
| '26' => ' SIGVTALRM', |
| '27' => ' SIGPROF', |
| '28' => ' SIGWINCH', |
| '29' => ' SIGINFO', |
| '30' => ' SIGUSR1', |
| '31' => ' SIGUSR2', |
| '145' => ' TARGET_EXC_BAD_ACCESS', # 0x91 |
| '146' => ' TARGET_EXC_BAD_INSTRUCTION', # 0x92 |
| '147' => ' TARGET_EXC_ARITHMETIC', # 0x93 |
| '148' => ' TARGET_EXC_EMULATION', # 0x94 |
| '149' => ' TARGET_EXC_SOFTWARE', # 0x95 |
| '150' => ' TARGET_EXC_BREAKPOINT' # 0x96 |
| ); |
| my $signo_str = sprintf("%i", $signo); |
| my $signo_name = ''; |
| if (exists $signo_to_name{$signo_str}) |
| { |
| $signo_name = $signo_to_name{$signo_str}; |
| } |
| printf ("signal (signo=%u$signo_name)\n", $signo); |
| dump_stop_reply_data (@_); |
| } |
| elsif ($what eq 'W') |
| { |
| print 'process_exited( ' . shift(@_) . shift(@_) . " )\n"; |
| } |
| elsif ($what eq 'X') |
| { |
| print 'process_terminated( ' . shift(@_) . shift(@_) . " )\n"; |
| } |
| elsif ($what eq 'O') |
| { |
| my $console_output = ''; |
| my $num_hex8_bytes = @_/2; |
| for (1 .. $num_hex8_bytes) |
| { |
| $console_output .= sprintf("%c", get8(\@_)) |
| } |
| |
| print "program_console_output('$console_output')\n"; |
| } |
| } |
| |
| #---------------------------------------------------------------------- |
| # '?' command |
| #---------------------------------------------------------------------- |
| sub dump_last_signal_cmd |
| { |
| my $cmd = shift; |
| print 'last_signal (' . join('',@_) . ")\n"; |
| } |
| |
| sub dump_raw_command |
| { |
| my $cmd_aref = shift; |
| my $callback_ref; |
| $curr_cmd = $$cmd_aref[0]; |
| |
| if ($curr_cmd eq 'q' or $curr_cmd eq 'Q' or $curr_cmd eq '_') |
| { |
| $curr_full_cmd = ''; |
| foreach my $ch (@$cmd_aref) |
| { |
| $ch !~ /[A-Za-z_]/ and last; |
| $curr_full_cmd .= $ch; |
| } |
| } |
| else |
| { |
| $curr_full_cmd = $curr_cmd; |
| } |
| |
| $curr_cmd eq '_' and $curr_cmd .= $$cmd_aref[1]; |
| $callback_ref = $cmd_callbacks{$curr_cmd}; |
| if ($callback_ref) |
| { |
| &$callback_ref(@$cmd_aref); |
| } |
| else |
| { |
| # Strip the command byte for responses since we injected that above |
| dump_other_cmd(@$cmd_aref); |
| } |
| } |
| |
| sub dump_standard_response |
| { |
| my $cmd_aref = shift; |
| |
| my $cmd_len = scalar(@$cmd_aref); |
| if ($cmd_len == 0) |
| { |
| print "$unimplemented_str\n"; |
| return 1; |
| } |
| |
| my $response = join('', @$cmd_aref); |
| if ($response eq 'OK') |
| { |
| print "$success_str\n"; |
| return 1; |
| } |
| |
| if ($cmd_len == 3 and index($response, 'E') == 0) |
| { |
| print "ERROR: " . substr($response, 1) . "\n"; |
| return 1; |
| } |
| |
| return 0; |
| } |
| sub dump_raw_response |
| { |
| my $cmd_aref = shift; |
| my $callback_ref; |
| |
| if ($packet_start_time != 0.0) |
| { |
| if (length($curr_full_cmd) > 0) |
| { |
| $packet_times{$curr_full_cmd} += $curr_time - $packet_start_time; |
| } |
| else |
| { |
| $packet_times{$curr_cmd} += $curr_time - $packet_start_time; |
| } |
| $packet_start_time = 0.0; |
| } |
| |
| $callback_ref = $rsp_callbacks{$curr_cmd}; |
| |
| if ($callback_ref) |
| { |
| &$callback_ref(@$cmd_aref); |
| } |
| else |
| { |
| dump_standard_response($cmd_aref) or dump_other_rsp(@$cmd_aref); |
| } |
| |
| } |
| #---------------------------------------------------------------------- |
| # Dumps any command and handles simple error checking on the responses |
| # for commands that are unsupported or OK. |
| #---------------------------------------------------------------------- |
| sub dump_command |
| { |
| my $cmd_str = shift; |
| |
| # Dump the original command string if verbose is on |
| if ($opt_v) |
| { |
| print "dump_command($cmd_str)\n "; |
| } |
| |
| my @cmd_chars = extract_command($cmd_str); |
| my $is_cmd = 1; |
| |
| my $cmd = $cmd_chars[0]; |
| if ($cmd eq '$') |
| { |
| $is_cmd = 0; # Note that this is a reply |
| $cmd = $curr_cmd; # set the command byte appropriately |
| shift @cmd_chars; # remove the '$' from the cmd bytes |
| } |
| |
| # Check for common responses across all commands and handle them |
| # if we can |
| if ( $is_cmd == 0 ) |
| { |
| if (rsp_is_unsupported(@cmd_chars)) |
| { |
| print "$unimplemented_str\n"; |
| return; |
| } |
| elsif (rsp_is_OK(@cmd_chars)) |
| { |
| print "$success_str\n"; |
| return; |
| } |
| # Strip the checksum information for responses |
| strip_checksum(\@cmd_chars); |
| } |
| |
| my $callback_ref; |
| if ($is_cmd) { |
| $callback_ref = $cmd_callbacks{$cmd}; |
| } else { |
| $callback_ref = $rsp_callbacks{$cmd}; |
| } |
| |
| if ($callback_ref) |
| { |
| &$callback_ref(@cmd_chars); |
| } |
| else |
| { |
| # Strip the command byte for responses since we injected that above |
| if ($is_cmd) { |
| dump_other_cmd(@cmd_chars); |
| } else { |
| dump_other_rsp(@cmd_chars); |
| } |
| |
| } |
| } |
| |
| |
| #---------------------------------------------------------------------- |
| # Process a gdbserver log line by looking for getpkt and putkpt and |
| # tossing any other lines. |
| |
| #---------------------------------------------------------------------- |
| sub process_log_line |
| { |
| my $line = shift; |
| #($opt_v and $opt_g) and print "# $line"; |
| |
| my $extract_cmd = 0; |
| my $delta_time = 0.0; |
| if ($line =~ /^(\s*)([1-9][0-9]+\.[0-9]+)([^0-9].*)$/) |
| { |
| my $leading_space = $1; |
| $curr_time = $2; |
| $line = $3; |
| if ($base_time == 0.0) |
| { |
| $base_time = $curr_time; |
| } |
| else |
| { |
| $delta_time = $curr_time - $last_time; |
| } |
| printf ("(%.6f, %+.6f): ", $curr_time - $base_time, $delta_time); |
| $last_time = $curr_time; |
| } |
| else |
| { |
| $curr_time = 0.0 |
| } |
| |
| if ($line =~ /getpkt /) |
| { |
| $extract_cmd = 1; |
| print "\n--> "; |
| $packet_start_time = $curr_time; |
| } |
| elsif ($line =~ /putpkt /) |
| { |
| $extract_cmd = 1; |
| print "<-- "; |
| } |
| elsif ($line =~ /.*Sent: \[[0-9]+\.[0-9]+[:0-9]*\] (.*)/) |
| { |
| $opt_g and print "maintenance dump-packets command: $1\n"; |
| my @raw_cmd_bytes = split(/ */, $1); |
| $packet_start_time = $curr_time; |
| print "\n--> "; |
| dump_raw_command(\@raw_cmd_bytes); |
| process_log_line($2); |
| } |
| elsif ($line =~ /.*Recvd: \[[0-9]+\.[0-9]+[:0-9]*\] (.*)/) |
| { |
| $opt_g and print "maintenance dump-packets reply: $1\n"; |
| my @raw_rsp_bytes = split(/ */, $1); |
| print "<-- "; |
| dump_raw_response(\@raw_rsp_bytes); |
| print "\n"; |
| } |
| elsif ($line =~ /getpkt: (.*)/) |
| { |
| if ($1 =~ /\$([^#]+)#[0-9a-fA-F]{2}/) |
| { |
| $opt_g and print "command: $1\n"; |
| my @raw_cmd_bytes = split(/ */, $1); |
| print "--> "; |
| $packet_start_time = $curr_time; |
| dump_raw_command(\@raw_cmd_bytes); |
| } |
| elsif ($1 =~ /\+/) |
| { |
| #print "--> ACK\n"; |
| } |
| elsif ($1 =~ /-/) |
| { |
| #print "--> NACK\n"; |
| } |
| } |
| elsif ($line =~ /putpkt: (.*)/) |
| { |
| if ($1 =~ /\$([^#]+)#[0-9a-fA-F]{2}/) |
| { |
| $opt_g and print "response: $1\n"; |
| my @raw_rsp_bytes = split(/ */, $1); |
| print "<-- "; |
| dump_raw_response(\@raw_rsp_bytes); |
| print "\n"; |
| } |
| elsif ($1 =~ /\+/) |
| { |
| #print "<-- ACK\n"; |
| } |
| elsif ($1 =~ /-/) |
| { |
| #print "<-- NACK\n"; |
| } |
| } |
| elsif ($line =~ /send packet: (.*)/) |
| { |
| if ($1 =~ /\$([^#]+)#[0-9a-fA-F]{2}/) |
| { |
| $opt_g and print "command: $1\n"; |
| my @raw_cmd_bytes = split(/ */, $1); |
| print "--> "; |
| $packet_start_time = $curr_time; |
| dump_raw_command(\@raw_cmd_bytes); |
| } |
| elsif ($1 =~ /\+/) |
| { |
| #print "--> ACK\n"; |
| } |
| elsif ($1 =~ /-/) |
| { |
| #print "--> NACK\n"; |
| } |
| } |
| elsif ($line =~ /read packet: (.*)/) |
| { |
| if ($1 =~ /\$([^#]*)#[0-9a-fA-F]{2}/) |
| { |
| $opt_g and print "response: $1\n"; |
| my @raw_rsp_bytes = split(/ */, $1); |
| print "<-- "; |
| dump_raw_response(\@raw_rsp_bytes); |
| print "\n"; |
| } |
| elsif ($1 =~ /\+/) |
| { |
| #print "<-- ACK\n"; |
| } |
| elsif ($1 =~ /-/) |
| { |
| #print "<-- NACK\n"; |
| } |
| } |
| elsif ($line =~ /Sending packet: \$([^#]+)#[0-9a-fA-F]{2}\.\.\.(.*)/) |
| { |
| $opt_g and print "command: $1\n"; |
| my @raw_cmd_bytes = split(/ */, $1); |
| print "\n--> "; |
| $packet_start_time = $curr_time; |
| dump_raw_command(\@raw_cmd_bytes); |
| process_log_line($2); |
| } |
| elsif ($line =~ /Packet received: (.*)/) |
| { |
| $opt_g and print "response: $1\n"; |
| my @raw_rsp_bytes = split(/ */, $1); |
| print "<-- "; |
| dump_raw_response(\@raw_rsp_bytes); |
| print "\n"; |
| } |
| |
| if ($extract_cmd) |
| { |
| my $beg = index($line, '("') + 2; |
| my $end = rindex($line, '");'); |
| $packet_start_time = $curr_time; |
| dump_command(substr($line, $beg, $end - $beg)); |
| } |
| } |
| |
| |
| our $line_num = 0; |
| while(<>) |
| { |
| $line_num++; |
| $opt_q or printf("# %5d: $_", $line_num); |
| process_log_line($_); |
| } |
| |
| if (%packet_times) |
| { |
| print "----------------------------------------------------------------------\n"; |
| print "Packet timing summary:\n"; |
| print "----------------------------------------------------------------------\n"; |
| print "Packet Time %\n"; |
| print "---------------------- -------- ------\n"; |
| my @packet_names = keys %packet_times; |
| my $total_packet_times = 0.0; |
| foreach my $key (@packet_names) |
| { |
| $total_packet_times += $packet_times{$key}; |
| } |
| |
| foreach my $value (sort {$packet_times{$b} cmp $packet_times{$a}} @packet_names) |
| { |
| my $percent = ($packet_times{$value} / $total_packet_times) * 100.0; |
| if ($percent < 10.0) |
| { |
| printf("%22s %1.6f %2.2f\n", $value, $packet_times{$value}, $percent); |
| |
| } |
| else |
| { |
| printf("%22s %1.6f %2.2f\n", $value, $packet_times{$value}, $percent); |
| } |
| } |
| print "---------------------- -------- ------\n"; |
| printf (" Total %1.6f 100.00\n", $total_packet_times); |
| } |
| |
| |
| |
| |
| |
| |
| |
