| blob | c0e7665cc726d56a862a933abe69a70ae0f977d9 |
1 #!/usr/bin/env perl
5 #----------------------------------------------------------------------
6 # Globals
7 #----------------------------------------------------------------------
86 ],
134 ],
212 ],
301 ],
361 ],
422 ]
423 );
426 calculate_max_register_name_length();
438 {
440 {
442 }
443 else
444 {
446 }
447 }
449 sub extract_key_value_pairs
450 {
456 {
459 }
461 }
463 sub get_thread_from_thread_suffix
464 {
466 {
468 # Skip leading semi-colon if needed
472 {
474 }
475 }
477 }
479 sub calculate_max_register_name_length
480 {
483 {
486 {
488 }
489 }
490 }
491 #----------------------------------------------------------------------
492 # Hash that maps command characters to the appropriate functions using
493 # the command character as the key and the value being a reference to
494 # the dump function for dumping the command itself.
495 #----------------------------------------------------------------------
497 (
520 # extended commands
522 );
524 #----------------------------------------------------------------------
525 # Hash that maps command characters to the appropriate functions using
526 # the command character as the key and the value being a reference to
527 # the dump function for the response to the command.
528 #----------------------------------------------------------------------
530 (
543 # extended commands
545 );
548 sub dump_register_value
549 {
555 {
558 }
563 {
564 printf("\t%*s: error: EOS reached when trying to read register %d\n", $max_register_name_len, $reg_name, $reg_num);
565 }
575 }
576 }
578 #----------------------------------------------------------------------
579 # Extract the command into an array of ASCII char strings for easy
580 # processing
581 #----------------------------------------------------------------------
582 sub extract_command
583 {
587 {
588 # only set the current command if it isn't a reply
590 }
592 }
594 #----------------------------------------------------------------------
595 # Strip the 3 checksum array entries after we don't need them anymore
596 #----------------------------------------------------------------------
597 sub strip_checksum
598 {
601 }
603 #----------------------------------------------------------------------
604 # Dump all strings in array by joining them together with no space
605 # between them
606 #----------------------------------------------------------------------
607 sub dump_chars
608 {
610 }
612 #----------------------------------------------------------------------
613 # Check if the response is an error 'EXX'
614 #----------------------------------------------------------------------
615 sub is_error_response
616 {
618 {
622 }
624 }
626 #----------------------------------------------------------------------
627 # 'H' command
628 #----------------------------------------------------------------------
629 sub dump_set_thread_cmd
630 {
634 }
636 #----------------------------------------------------------------------
637 # 'T' command
638 #----------------------------------------------------------------------
640 sub dump_thread_is_alive_cmd
641 {
645 }
647 sub dump_thread_is_alive_rsp
648 {
653 {
655 }
656 else
657 {
659 }
660 }
662 #----------------------------------------------------------------------
663 # 'H' response
664 #----------------------------------------------------------------------
665 sub dump_set_thread_rsp
666 {
668 {
670 }
671 }
673 #----------------------------------------------------------------------
674 # 'q' command
675 #----------------------------------------------------------------------
678 sub dump_general_query_cmd
679 {
682 {
684 }
686 {
688 }
690 {
692 }
694 {
695 # qThreadExtraInfo,id
697 }
699 {
700 # qThreadStopInfoXXXX
704 }
706 {
707 # qCRC:addr,length
709 }
711 {
712 # qCRC:addr,length
718 }
720 {
721 # qGetTLSAddr:thread-id,offset,lm
725 }
727 {
729 }
731 {
736 }
737 else
738 {
740 }
742 }
744 #----------------------------------------------------------------------
745 # 'q' response
746 #----------------------------------------------------------------------
747 sub dump_general_query_rsp
748 {
752 {
757 }
759 {
761 {
763 }
764 else
765 {
767 {
776 {
781 }
783 {
784 if ($byte_size == 4) {push @$registers_aref, { name => $reg_name, info => $reg32_href , pseudo => $pseudo };}
785 elsif ($byte_size == 8) {push @$registers_aref, { name => $reg_name, info => $reg64_href , pseudo => $pseudo };}
786 elsif ($byte_size == 1) {push @$registers_aref, { name => $reg_name, info => $reg8_href , pseudo => $pseudo };}
787 elsif ($byte_size == 2) {push @$registers_aref, { name => $reg_name, info => $reg16_href , pseudo => $pseudo };}
788 elsif ($byte_size == 10) {push @$registers_aref, { name => $reg_name, info => $reg80_href , pseudo => $pseudo };}
789 elsif ($byte_size == 12) {push @$registers_aref, { name => $reg_name, info => $float96_href , pseudo => $pseudo };}
790 elsif ($byte_size == 16) {push @$registers_aref, { name => $reg_name, info => $reg128_href , pseudo => $pseudo };}
791 elsif ($byte_size == 32) {push @$registers_aref, { name => $reg_name, info => $reg256_href , pseudo => $pseudo };}
792 }
793 }
795 {
796 calculate_max_register_name_length();
797 }
798 }
799 }
801 {
803 }
805 {
806 # Do nothing...
807 }
808 else
809 {
811 }
812 }
814 #----------------------------------------------------------------------
815 # 'Q' command
816 #----------------------------------------------------------------------
818 sub dump_general_set_cmd
819 {
822 {
824 }
826 {
829 }
831 {
834 # QSetMaxPayloadSize:XXXX where XXXX is a hex length of the max
835 # packet payload size supported by gdb
837 }
839 {
842 }
844 {
847 }
849 {
852 }
853 else
854 {
856 }
858 }
860 #----------------------------------------------------------------------
861 # 'k' command
862 #----------------------------------------------------------------------
863 sub dump_kill_cmd
864 {
867 }
869 #----------------------------------------------------------------------
870 # 'g' command
871 #----------------------------------------------------------------------
872 sub dump_read_regs_cmd
873 {
876 }
878 #----------------------------------------------------------------------
879 # 'G' command
880 #----------------------------------------------------------------------
881 sub dump_write_regs_cmd
882 {
886 {
889 {
896 }
897 }
898 }
900 sub dump_read_regs_rsp
901 {
904 {
905 # print join('',@_) . "\n";
907 {
910 {
917 }
918 }
919 }
920 }
922 sub dump_read_single_register_rsp
923 {
926 }
928 #----------------------------------------------------------------------
929 # '_M' - allocate memory command (LLDB extension)
930 #
931 # Command: '_M'
932 # Arg1: Hex byte size as big endian hex string
933 # Separator: ','
934 # Arg2: permissions as string that must be a string that contains any
935 # combination of 'r' (readable) 'w' (writable) or 'x' (executable)
936 #
937 # Returns: The address that was allocated as a big endian hex string
938 # on success, else an error "EXX" where XX are hex bytes
939 # that indicate an error code.
940 #
941 # Examples:
942 # _M10,rw # allocate 16 bytes with read + write permissions
943 # _M100,rx # allocate 256 bytes with read + execute permissions
944 #----------------------------------------------------------------------
945 sub dump_allocate_memory_cmd
946 {
950 printf("allocate_memory ( byte_size = %u (0x%x), permissions = %s)\n", $byte_size, $byte_size, join('',@_));
951 }
953 sub dump_allocate_memory_rsp
954 {
956 {
958 }
959 else
960 {
962 }
963 }
965 #----------------------------------------------------------------------
966 # '_m' - deallocate memory command (LLDB extension)
967 #
968 # Command: '_m'
969 # Arg1: Hex address as big endian hex string
970 #
971 # Returns: "OK" on success "EXX" on error
972 #
973 # Examples:
974 # _m201000 # Free previously allocated memory at address 0x201000
975 #----------------------------------------------------------------------
976 sub dump_deallocate_memory_cmd
977 {
980 }
983 #----------------------------------------------------------------------
984 # 'p' command
985 #----------------------------------------------------------------------
986 sub dump_read_single_register_cmd
987 {
994 {
996 }
997 else
998 {
1000 }
1001 }
1004 #----------------------------------------------------------------------
1005 # 'P' command
1006 #----------------------------------------------------------------------
1007 sub dump_write_single_register_cmd
1008 {
1017 {
1019 }
1021 }
1023 #----------------------------------------------------------------------
1024 # 'm' command
1025 #----------------------------------------------------------------------
1027 sub dump_read_mem_cmd
1028 {
1033 }
1035 #----------------------------------------------------------------------
1036 # 'm' response
1037 #----------------------------------------------------------------------
1038 sub dump_read_mem_rsp
1039 {
1040 # If the memory read was 2 or 4 bytes, print it out in native format
1041 # instead of just as bytes.
1044 {
1046 }
1048 {
1050 }
1052 {
1054 }
1056 {
1058 }
1059 else
1060 {
1066 {
1068 {
1071 }
1075 }
1076 }
1078 }
1080 #----------------------------------------------------------------------
1081 # 'c' or 's' command
1082 #----------------------------------------------------------------------
1083 sub dump_continue_cmd
1084 {
1091 {
1094 }
1095 else
1096 {
1098 }
1099 }
1101 #----------------------------------------------------------------------
1102 # 'Css' continue (C) with signal (ss where 'ss' is two hex digits)
1103 # 'Sss' step (S) with signal (ss where 'ss' is two hex digits)
1104 #----------------------------------------------------------------------
1105 sub dump_continue_with_signal_cmd
1106 {
1114 {
1117 {
1120 }
1121 }
1124 {
1125 printf("%s_with_signal (signal = 0x%2.2x, address = $addr_format)\n", $cmd_str, $signal, $address);
1126 }
1127 else
1128 {
1130 }
1131 }
1133 #----------------------------------------------------------------------
1134 # 'A' command
1135 #----------------------------------------------------------------------
1136 sub dump_A_command
1137 {
1138 my $cmd = get_expected_char(\@_, 'A') or print "error: incorrect command letter for argument packet, expected 'A'\n";
1140 do
1141 {
1150 {
1152 }
1155 {
1156 get_expected_char(\@_, ',') or die "error: missing comma after argument argument ASCII hex bytes...?\n";
1157 }
1160 }
1163 #----------------------------------------------------------------------
1164 # 'z' and 'Z' command
1165 #----------------------------------------------------------------------
1166 sub dump_bp_wp_command
1167 {
1175 {
1177 }
1178 else
1179 {
1181 }
1182 }
1185 #----------------------------------------------------------------------
1186 # 'X' command
1187 #----------------------------------------------------------------------
1188 sub dump_write_mem_binary_cmd
1189 {
1197 }
1199 #----------------------------------------------------------------------
1200 # 'M' command
1201 #----------------------------------------------------------------------
1202 sub dump_write_mem_cmd
1203 {
1208 # printf("write_mem ( $addr_format, %d, %s)\n", $address, $length, $hex_bytes);
1209 printf("write_mem ( addr = $addr_format, len = %d (0x%x), bytes = ", $address, $length, $length);
1217 {
1221 }
1223 # If the memory to write is 2 or 4 bytes, print it out in native format
1224 # instead of just as bytes.
1226 {
1228 }
1230 {
1232 }
1235 }
1237 #----------------------------------------------------------------------
1238 # 'v' command
1239 #----------------------------------------------------------------------
1241 sub dump_extended_cmd
1242 {
1245 {
1247 }
1249 {
1251 }
1253 {
1255 }
1256 }
1258 #----------------------------------------------------------------------
1259 # 'v' response
1260 #----------------------------------------------------------------------
1261 sub dump_extended_rsp
1262 {
1264 {
1266 }
1268 }
1270 #----------------------------------------------------------------------
1271 # 'vAttachWait' command
1272 #----------------------------------------------------------------------
1273 sub dump_attach_wait_command
1274 {
1277 {
1279 }
1282 }
1284 #----------------------------------------------------------------------
1285 # 'vAttach' command
1286 #----------------------------------------------------------------------
1287 sub dump_attach_command
1288 {
1291 }
1293 #----------------------------------------------------------------------
1294 # 'vCont' command
1295 #----------------------------------------------------------------------
1296 sub dump_extended_continue_cmd
1297 {
1301 {
1304 }
1306 {
1310 {
1312 {
1314 }
1318 {
1320 }
1322 {
1326 }
1328 {
1330 }
1332 {
1336 }
1339 {
1343 {
1349 }
1350 }
1351 }
1353 }
1356 }
1357 }
1359 #----------------------------------------------------------------------
1360 # 'vCont' response
1361 #----------------------------------------------------------------------
1362 sub dump_extended_continue_rsp
1363 {
1365 {
1367 }
1368 else
1369 {
1371 }
1372 }
1374 #----------------------------------------------------------------------
1375 # Dump the command ascii for any unknown commands
1376 #----------------------------------------------------------------------
1377 sub dump_other_cmd
1378 {
1380 }
1382 #----------------------------------------------------------------------
1383 # Check to see if the response was unsupported with appropriate checksum
1384 #----------------------------------------------------------------------
1385 sub rsp_is_unsupported
1386 {
1388 }
1390 #----------------------------------------------------------------------
1391 # Check to see if the response was "OK" with appropriate checksum
1392 #----------------------------------------------------------------------
1393 sub rsp_is_OK
1394 {
1396 }
1398 #----------------------------------------------------------------------
1399 # Dump a response for an unknown command
1400 #----------------------------------------------------------------------
1401 sub dump_other_rsp
1402 {
1404 }
1406 #----------------------------------------------------------------------
1407 # Get a byte from the ascii string assuming that the 2 nibble ascii
1408 # characters are in hex.
1409 #
1410 # The argument for this function needs to be a reference to an array
1411 # that contains single character strings and the array will get
1412 # updated by shifting characters off the front of it (no leading # "0x")
1413 #----------------------------------------------------------------------
1414 sub get8
1415 {
1419 }
1421 #----------------------------------------------------------------------
1422 # Get a 16 bit integer and swap if $swap global is set to a non-zero
1423 # value.
1424 #
1425 # The argument for this function needs to be a reference to an array
1426 # that contains single character strings and the array will get
1427 # updated by shifting characters off the front of it (no leading # "0x")
1428 #----------------------------------------------------------------------
1429 sub get16
1430 {
1434 {
1437 }
1438 else
1439 {
1442 }
1444 }
1446 #----------------------------------------------------------------------
1447 # Get a 32 bit integer and swap if $swap global is set to a non-zero
1448 # value.
1449 #
1450 # The argument for this function needs to be a reference to an array
1451 # that contains single character strings and the array will get
1452 # updated by shifting characters off the front of it (no leading # "0x")
1453 #----------------------------------------------------------------------
1454 sub get32
1455 {
1459 {
1464 }
1465 else
1466 {
1471 }
1473 }
1475 #----------------------------------------------------------------------
1476 # Get a 64 bit hex value as a string
1477 #
1478 # The argument for this function needs to be a reference to an array
1479 # that contains single character strings and the array will get
1480 # updated by shifting characters off the front of it (no leading # "0x")
1481 #----------------------------------------------------------------------
1482 sub get64
1483 {
1488 {
1497 }
1498 else
1499 {
1501 }
1504 }
1506 #----------------------------------------------------------------------
1507 # Get a 80 bit hex value as a string
1508 #
1509 # The argument for this function needs to be a reference to an array
1510 # that contains single character strings and the array will get
1511 # updated by shifting characters off the front of it (no leading # "0x")
1512 #----------------------------------------------------------------------
1513 sub get80
1514 {
1519 {
1530 }
1531 else
1532 {
1534 }
1537 }
1539 #----------------------------------------------------------------------
1540 # Get a 96 bit hex value as a string
1541 #
1542 # The argument for this function needs to be a reference to an array
1543 # that contains single character strings and the array will get
1544 # updated by shifting characters off the front of it (no leading # "0x")
1545 #----------------------------------------------------------------------
1546 sub get96
1547 {
1552 {
1565 }
1566 else
1567 {
1569 }
1572 }
1574 #----------------------------------------------------------------------
1575 # Get a 128 bit hex value as a string
1576 #
1577 # The argument for this function needs to be a reference to an array
1578 # that contains single character strings and the array will get
1579 # updated by shifting characters off the front of it (no leading # "0x")
1580 #----------------------------------------------------------------------
1581 sub get128
1582 {
1587 {
1604 }
1605 else
1606 {
1608 }
1611 }
1613 #----------------------------------------------------------------------
1614 # Get a 256 bit hex value as a string
1615 #
1616 # The argument for this function needs to be a reference to an array
1617 # that contains single character strings and the array will get
1618 # updated by shifting characters off the front of it (no leading # "0x")
1619 #----------------------------------------------------------------------
1620 sub get256
1621 {
1626 {
1659 }
1660 else
1661 {
1663 }
1666 }
1668 #----------------------------------------------------------------------
1669 # Get an unsigned integer value by grabbing items off the front of
1670 # the array stopping when a non-digit char string is encountered.
1671 #
1672 # The argument for this function needs to be a reference to an array
1673 # that contains single character strings and the array will get
1674 # updated by shifting characters off the front of it
1675 #----------------------------------------------------------------------
1676 sub get_uint
1677 {
1682 {
1684 }
1686 }
1688 #----------------------------------------------------------------------
1689 # Check the first character in the array and if it matches the expected
1690 # character, return that character, else return undef;
1691 #
1692 # The argument for this function needs to be a reference to an array
1693 # that contains single character strings and the array will get
1694 # updated by shifting characters off the front of it. If the expected
1695 # character doesn't match, it won't touch the array. If the first
1696 # character does match, it will shift it off and return it.
1697 #----------------------------------------------------------------------
1698 sub get_expected_char
1699 {
1703 {
1705 }
1707 }
1708 #----------------------------------------------------------------------
1709 # Get a hex value by grabbing items off the front of the array and
1710 # stopping when a non-hex char string is encountered.
1711 #
1712 # The argument for this function needs to be a reference to an array
1713 # that contains single character strings and the array will get
1714 # updated by shifting characters off the front of it (no leading # "0x")
1715 #----------------------------------------------------------------------
1716 sub get_hex
1717 {
1723 {
1725 {
1729 }
1730 else
1731 {
1734 }
1735 }
1737 }
1739 #----------------------------------------------------------------------
1740 # Get an address value by grabbing items off the front of the array.
1741 #
1742 # The argument for this function needs to be a reference to an array
1743 # that contains single character strings and the array will get
1744 # updated by shifting characters off the front of it (no leading # "0x")
1745 #----------------------------------------------------------------------
1746 sub get_addr
1747 {
1749 }
1751 sub get_hex_string
1752 {
1756 {
1761 }
1763 }
1765 sub dump_stop_reply_data
1766 {
1768 {
1776 {
1780 {
1785 }
1787 }
1791 {
1793 {
1797 }
1798 }
1801 {
1805 }
1807 {
1819 );
1821 {
1823 }
1824 }
1826 }
1827 }
1829 #----------------------------------------------------------------------
1830 # Dumps a Stop Reply Packet which happens in response to a step,
1831 # continue, last signal, and probably a few other commands.
1832 #----------------------------------------------------------------------
1833 sub dump_stop_reply_packet
1834 {
1837 {
1878 );
1882 {
1884 }
1887 }
1889 {
1891 }
1893 {
1895 }
1897 {
1901 {
1903 }
1906 }
1907 }
1909 #----------------------------------------------------------------------
1910 # '?' command
1911 #----------------------------------------------------------------------
1912 sub dump_last_signal_cmd
1913 {
1916 }
1918 sub dump_raw_command
1919 {
1925 {
1928 {
1931 }
1932 }
1933 else
1934 {
1936 }
1941 {
1943 }
1944 else
1945 {
1946 # Strip the command byte for responses since we injected that above
1948 }
1949 }
1951 sub dump_standard_response
1952 {
1957 {
1960 }
1964 {
1967 }
1970 {
1973 }
1976 }
1977 sub dump_raw_response
1978 {
1983 {
1985 {
1987 }
1988 else
1989 {
1991 }
1993 }
1998 {
2000 }
2001 else
2002 {
2004 }
2006 }
2007 #----------------------------------------------------------------------
2008 # Dumps any command and handles simple error checking on the responses
2009 # for commands that are unsupported or OK.
2010 #----------------------------------------------------------------------
2011 sub dump_command
2012 {
2015 # Dump the original command string if verbose is on
2017 {
2019 }
2026 {
2030 }
2032 # Check for common responses across all commands and handle them
2033 # if we can
2035 {
2037 {
2040 }
2042 {
2045 }
2046 # Strip the checksum information for responses
2048 }
2055 }
2058 {
2060 }
2061 else
2062 {
2063 # Strip the command byte for responses since we injected that above
2068 }
2070 }
2071 }
2074 #----------------------------------------------------------------------
2075 # Process a gdbserver log line by looking for getpkt and putkpt and
2076 # tossing any other lines.
2078 #----------------------------------------------------------------------
2079 sub process_log_line
2080 {
2082 #($opt_v and $opt_g) and print "# $line";
2087 {
2092 {
2094 }
2095 else
2096 {
2098 }
2101 }
2102 else
2103 {
2105 }
2108 {
2112 }
2114 {
2117 }
2119 {
2126 }
2128 {
2134 }
2136 {
2138 {
2144 }
2146 {
2147 #print "--> ACK\n";
2148 }
2150 {
2151 #print "--> NACK\n";
2152 }
2153 }
2155 {
2157 {
2163 }
2165 {
2166 #print "<-- ACK\n";
2167 }
2169 {
2170 #print "<-- NACK\n";
2171 }
2172 }
2174 {
2176 {
2182 }
2184 {
2185 #print "--> ACK\n";
2186 }
2188 {
2189 #print "--> NACK\n";
2190 }
2191 }
2193 {
2195 {
2201 }
2203 {
2204 #print "<-- ACK\n";
2205 }
2207 {
2208 #print "<-- NACK\n";
2209 }
2210 }
2212 {
2219 }
2221 {
2227 }
2230 {
2235 }
2236 }
2241 {
2245 }
2248 {
2257 {
2259 }
2262 {
2265 {
2268 }
2269 else
2270 {
2272 }
2273 }
2276 }