#!/usr/bin/env 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); }