Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-11-27 07:31:28 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
e6d219122d
llvm-capstone/lldb/scripts/disasm-gdb-remote.pl
Bruce Mitchener d93c4a3339 Fix typos. 
llvm-svn: 212132
2014-07-01 21:22:11 +00:00

2284 lines
70 KiB
Perl
Executable File
Raw Blame History

#!/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);
}
Reference in New Issue View Git Blame Copy Permalink