riscv/gdbserver.cc

   1 #include <arpa/inet.h>
   2 #include <errno.h>
   3 #include <fcntl.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6 #include <sys/socket.h>
   7 #include <sys/types.h>
   8 #include <unistd.h>
   9
  10 #include <algorithm>
  11 #include <cassert>
  12 #include <cstdio>
  13 #include <vector>
  14
  15 #include "disasm.h"
  16 #include "sim.h"
  17 #include "gdbserver.h"
  18 #include "mmu.h"
  19
  20 #define C_EBREAK        0x9002
  21 #define EBREAK          0x00100073
  22
  23 template <typename T>
  24 unsigned int circular_buffer_t<T>::size() const
  25 {
  26   if (end >= start)
  27     return end - start;
  28   else
  29     return end + capacity - start;
  30 }
  31
  32 template <typename T>
  33 void circular_buffer_t<T>::consume(unsigned int bytes)
  34 {
  35   start = (start + bytes) % capacity;
  36 }
  37
  38 template <typename T>
  39 unsigned int circular_buffer_t<T>::contiguous_empty_size() const
  40 {
  41   if (end >= start)
  42     if (start == 0)
  43       return capacity - end - 1;
  44     else
  45       return capacity - end;
  46   else
  47     return start - end - 1;
  48 }
  49
  50 template <typename T>
  51 unsigned int circular_buffer_t<T>::contiguous_data_size() const
  52 {
  53   if (end >= start)
  54     return end - start;
  55   else
  56     return capacity - start;
  57 }
  58
  59 template <typename T>
  60 void circular_buffer_t<T>::data_added(unsigned int bytes)
  61 {
  62   end += bytes;
  63   assert(end <= capacity);
  64   if (end == capacity)
  65     end = 0;
  66 }
  67
  68 template <typename T>
  69 void circular_buffer_t<T>::reset()
  70 {
  71   start = 0;
  72   end = 0;
  73 }
  74
  75 template <typename T>
  76 void circular_buffer_t<T>::append(const T *src, unsigned int count)
  77 {
  78   unsigned int copy = std::min(count, contiguous_empty_size());
  79   memcpy(contiguous_empty(), src, copy * sizeof(T));
  80   data_added(copy);
  81   count -= copy;
  82   if (count > 0) {
  83     assert(count < contiguous_empty_size());
  84     memcpy(contiguous_empty(), src, count * sizeof(T));
  85     data_added(count);
  86   }
  87 }
  88
  89 gdbserver_t::gdbserver_t(uint16_t port, sim_t *sim) :
  90   sim(sim),
  91   client_fd(0),
  92   recv_buf(64 * 1024), send_buf(64 * 1024)
  93 {
  94   socket_fd = socket(AF_INET, SOCK_STREAM, 0);
  95   if (socket_fd == -1) {
  96     fprintf(stderr, "failed to make socket: %s (%d)\n", strerror(errno), errno);
  97     abort();
  98   }
  99
 100   fcntl(socket_fd, F_SETFL, O_NONBLOCK);
 101   int reuseaddr = 1;
 102   if (setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,
 103         sizeof(int)) == -1) {
 104     fprintf(stderr, "failed setsockopt: %s (%d)\n", strerror(errno), errno);
 105     abort();
 106   }
 107
 108   struct sockaddr_in addr;
 109   memset(&addr, 0, sizeof(addr));
 110   addr.sin_family = AF_INET;
 111   addr.sin_addr.s_addr = INADDR_ANY;
 112   addr.sin_port = htons(port);
 113
 114   if (bind(socket_fd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
 115     fprintf(stderr, "failed to bind socket: %s (%d)\n", strerror(errno), errno);
 116     abort();
 117   }
 118
 119   if (listen(socket_fd, 1) == -1) {
 120     fprintf(stderr, "failed to listen on socket: %s (%d)\n", strerror(errno), errno);
 121     abort();
 122   }
 123 }
 124
 125 void gdbserver_t::accept()
 126 {
 127   client_fd = ::accept(socket_fd, NULL, NULL);
 128   if (client_fd == -1) {
 129     if (errno == EAGAIN) {
 130       // No client waiting to connect right now.
 131     } else {
 132       fprintf(stderr, "failed to accept on socket: %s (%d)\n", strerror(errno),
 133           errno);
 134       abort();
 135     }
 136   } else {
 137     fcntl(client_fd, F_SETFL, O_NONBLOCK);
 138
 139     expect_ack = false;
 140     extended_mode = false;
 141
 142     // gdb wants the core to be halted when it attaches.
 143     processor_t *p = sim->get_core(0);
 144     p->set_halted(true, HR_ATTACHED);
 145   }
 146 }
 147
 148 void gdbserver_t::read()
 149 {
 150   // Reading from a non-blocking socket still blocks if there is no data
 151   // available.
 152
 153   size_t count = recv_buf.contiguous_empty_size();
 154   assert(count > 0);
 155   ssize_t bytes = ::read(client_fd, recv_buf.contiguous_empty(), count);
 156   if (bytes == -1) {
 157     if (errno == EAGAIN) {
 158       // We'll try again the next call.
 159     } else {
 160       fprintf(stderr, "failed to read on socket: %s (%d)\n", strerror(errno), errno);
 161       abort();
 162     }
 163   } else if (bytes == 0) {
 164     // The remote disconnected.
 165     client_fd = 0;
 166     processor_t *p = sim->get_core(0);
 167     p->set_halted(false, HR_NONE);
 168     recv_buf.reset();
 169     send_buf.reset();
 170   } else {
 171     recv_buf.data_added(bytes);
 172   }
 173 }
 174
 175 void gdbserver_t::write()
 176 {
 177   if (send_buf.empty())
 178     return;
 179
 180   while (!send_buf.empty()) {
 181     unsigned int count = send_buf.contiguous_data_size();
 182     assert(count > 0);
 183     ssize_t bytes = ::write(client_fd, send_buf.contiguous_data(), count);
 184     if (bytes == -1) {
 185       fprintf(stderr, "failed to write to socket: %s (%d)\n", strerror(errno), errno);
 186       abort();
 187     } else if (bytes == 0) {
 188       // Client can't take any more data right now.
 189       break;
 190     } else {
 191       fprintf(stderr, "wrote %ld bytes: ", bytes);
 192       for (unsigned int i = 0; i < bytes; i++) {
 193         fprintf(stderr, "%c", send_buf[i]);
 194       }
 195       fprintf(stderr, "\n");
 196       send_buf.consume(bytes);
 197     }
 198   }
 199 }
 200
 201 void print_packet(const std::vector<uint8_t> &packet)
 202 {
 203   for (uint8_t c : packet) {
 204     if (c >= ' ' and c <= '~')
 205       fprintf(stderr, "%c", c);
 206     else
 207       fprintf(stderr, "\\x%x", c);
 208   }
 209   fprintf(stderr, "\n");
 210 }
 211
 212 uint8_t compute_checksum(const std::vector<uint8_t> &packet)
 213 {
 214   uint8_t checksum = 0;
 215   for (auto i = packet.begin() + 1; i != packet.end() - 3; i++ ) {
 216     checksum += *i;
 217   }
 218   return checksum;
 219 }
 220
 221 uint8_t character_hex_value(uint8_t character)
 222 {
 223   if (character >= '0' && character <= '9')
 224     return character - '0';
 225   if (character >= 'a' && character <= 'f')
 226     return 10 + character - 'a';
 227   if (character >= 'A' && character <= 'F')
 228     return 10 + character - 'A';
 229   return 0xff;
 230 }
 231
 232 uint8_t extract_checksum(const std::vector<uint8_t> &packet)
 233 {
 234   return character_hex_value(*(packet.end() - 1)) +
 235     16 * character_hex_value(*(packet.end() - 2));
 236 }
 237
 238 void gdbserver_t::process_requests()
 239 {
 240   // See https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
 241
 242   while (!recv_buf.empty()) {
 243     std::vector<uint8_t> packet;
 244     for (unsigned int i = 0; i < recv_buf.size(); i++) {
 245       uint8_t b = recv_buf[i];
 246
 247       if (packet.empty() && expect_ack && b == '+') {
 248         recv_buf.consume(1);
 249         break;
 250       }
 251
 252       if (packet.empty() && b == 3) {
 253         fprintf(stderr, "Received interrupt\n");
 254         recv_buf.consume(1);
 255         handle_interrupt();
 256         break;
 257       }
 258
 259       if (b == '$') {
 260         // Start of new packet.
 261         if (!packet.empty()) {
 262           fprintf(stderr, "Received malformed %ld-byte packet from debug client: ",
 263               packet.size());
 264           print_packet(packet);
 265           recv_buf.consume(i);
 266           break;
 267         }
 268       }
 269
 270       packet.push_back(b);
 271
 272       // Packets consist of $<packet-data>#<checksum>
 273       // where <checksum> is
 274       if (packet.size() >= 4 &&
 275           packet[packet.size()-3] == '#') {
 276         handle_packet(packet);
 277         recv_buf.consume(i+1);
 278         break;
 279       }
 280     }
 281     // There's a partial packet in the buffer. Wait until we get more data to
 282     // process it.
 283     if (packet.size()) {
 284       break;
 285     }
 286   }
 287 }
 288
 289 void gdbserver_t::handle_halt_reason(const std::vector<uint8_t> &packet)
 290 {
 291   send_packet("S00");
 292 }
 293
 294 void gdbserver_t::handle_general_registers_read(const std::vector<uint8_t> &packet)
 295 {
 296   // Register order that gdb expects is:
 297   //   "x0",  "x1",  "x2",  "x3",  "x4",  "x5",  "x6",  "x7",
 298   //   "x8",  "x9",  "x10", "x11", "x12", "x13", "x14", "x15",
 299   //   "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23",
 300   //   "x24", "x25", "x26", "x27", "x28", "x29", "x30", "x31",
 301
 302   // Each byte of register data is described by two hex digits. The bytes with
 303   // the register are transmitted in target byte order. The size of each
 304   // register and their position within the ‘g’ packet are determined by the
 305   // gdb internal gdbarch functions DEPRECATED_REGISTER_RAW_SIZE and
 306   // gdbarch_register_name.
 307
 308   send("$");
 309   running_checksum = 0;
 310   processor_t *p = sim->get_core(0);
 311   for (int r = 0; r < 32; r++) {
 312     send(p->state.XPR[r]);
 313   }
 314   send_running_checksum();
 315   expect_ack = true;
 316 }
 317
 318 // First byte is the most-significant one.
 319 // Eg. "08675309" becomes 0x08675309.
 320 uint64_t consume_hex_number(std::vector<uint8_t>::const_iterator &iter,
 321     std::vector<uint8_t>::const_iterator end)
 322 {
 323   uint64_t value = 0;
 324
 325   while (iter != end) {
 326     uint8_t c = *iter;
 327     uint64_t c_value = character_hex_value(c);
 328     if (c_value > 15)
 329       break;
 330     iter++;
 331     value <<= 4;
 332     value += c_value;
 333   }
 334   return value;
 335 }
 336
 337 // First byte is the least-significant one.
 338 // Eg. "08675309" becomes 0x09536708
 339 uint64_t consume_hex_number_le(std::vector<uint8_t>::const_iterator &iter,
 340     std::vector<uint8_t>::const_iterator end)
 341 {
 342   uint64_t value = 0;
 343   unsigned int shift = 4;
 344
 345   while (iter != end) {
 346     uint8_t c = *iter;
 347     uint64_t c_value = character_hex_value(c);
 348     if (c_value > 15)
 349       break;
 350     iter++;
 351     value |= c_value << shift;
 352     if ((shift % 8) == 0)
 353       shift += 12;
 354     else
 355       shift -= 4;
 356   }
 357   return value;
 358 }
 359
 360 void consume_string(std::string &str, std::vector<uint8_t>::const_iterator &iter,
 361     std::vector<uint8_t>::const_iterator end, uint8_t separator)
 362 {
 363   while (iter != end && *iter != separator) {
 364     str.append(1, (char) *iter);
 365     iter++;
 366   }
 367 }
 368
 369 // gdb's register list is defined in riscv_gdb_reg_names gdb/riscv-tdep.c in
 370 // its source tree. We must interpret the numbers the same here.
 371 enum {
 372   REG_XPR0 = 0,
 373   REG_XPR31 = 31,
 374   REG_PC = 32,
 375   REG_FPR0 = 33,
 376   REG_FPR31 = 64,
 377   REG_CSR0 = 65,
 378   REG_CSR4095 = 4160,
 379   REG_END = 4161
 380 };
 381
 382 void gdbserver_t::handle_register_read(const std::vector<uint8_t> &packet)
 383 {
 384   // p n
 385
 386   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 387   unsigned int n = consume_hex_number(iter, packet.end());
 388   if (*iter != '#')
 389     return send_packet("E01");
 390
 391   processor_t *p = sim->get_core(0);
 392   send("$");
 393   running_checksum = 0;
 394
 395   if (n >= REG_XPR0 && n <= REG_XPR31) {
 396     send(p->state.XPR[n - REG_XPR0]);
 397   } else if (n == REG_PC) {
 398     send(p->state.pc);
 399   } else if (n >= REG_FPR0 && n <= REG_FPR31) {
 400     send(p->state.FPR[n - REG_FPR0]);
 401   } else if (n >= REG_CSR0 && n <= REG_CSR4095) {
 402     try {
 403       send(p->get_csr(n - REG_CSR0));
 404     } catch(trap_t& t) {
 405       // It would be nicer to return an error here, but if you do that then gdb
 406       // exits out of 'info registers all' as soon as it encounters a register
 407       // that can't be read.
 408       send((reg_t) 0);
 409     }
 410   } else {
 411     return send_packet("E02");
 412   }
 413
 414   send_running_checksum();
 415   expect_ack = true;
 416 }
 417
 418 void gdbserver_t::handle_register_write(const std::vector<uint8_t> &packet)
 419 {
 420   // P n...=r...
 421
 422   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 423   unsigned int n = consume_hex_number(iter, packet.end());
 424   if (*iter != '=')
 425     return send_packet("E05");
 426   iter++;
 427
 428   reg_t value = consume_hex_number_le(iter, packet.end());
 429   if (*iter != '#')
 430     return send_packet("E06");
 431
 432   processor_t *p = sim->get_core(0);
 433
 434   if (n >= REG_XPR0 && n <= REG_XPR31) {
 435     p->state.XPR.write(n - REG_XPR0, value);
 436   } else if (n == REG_PC) {
 437     p->state.pc = value;
 438   } else if (n >= REG_FPR0 && n <= REG_FPR31) {
 439     p->state.FPR.write(n - REG_FPR0, value);
 440   } else if (n >= REG_CSR0 && n <= REG_CSR4095) {
 441     try {
 442       p->set_csr(n - REG_CSR0, value);
 443     } catch(trap_t& t) {
 444       return send_packet("EFF");
 445     }
 446   } else {
 447     return send_packet("E07");
 448   }
 449
 450   return send_packet("OK");
 451 }
 452
 453 void gdbserver_t::handle_memory_read(const std::vector<uint8_t> &packet)
 454 {
 455   // m addr,length
 456   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 457   reg_t address = consume_hex_number(iter, packet.end());
 458   if (*iter != ',')
 459     return send_packet("E10");
 460   iter++;
 461   reg_t length = consume_hex_number(iter, packet.end());
 462   if (*iter != '#')
 463     return send_packet("E11");
 464
 465   send("$");
 466   running_checksum = 0;
 467   char buffer[3];
 468   processor_t *p = sim->get_core(0);
 469   mmu_t* mmu = sim->debug_mmu;
 470
 471   for (reg_t i = 0; i < length; i++) {
 472     sprintf(buffer, "%02x", mmu->load_uint8(address + i));
 473     send(buffer);
 474   }
 475   send_running_checksum();
 476 }
 477
 478 void gdbserver_t::handle_memory_binary_write(const std::vector<uint8_t> &packet)
 479 {
 480   // X addr,length:XX...
 481   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 482   reg_t address = consume_hex_number(iter, packet.end());
 483   if (*iter != ',')
 484     return send_packet("E20");
 485   iter++;
 486   reg_t length = consume_hex_number(iter, packet.end());
 487   if (*iter != ':')
 488     return send_packet("E21");
 489   iter++;
 490
 491   processor_t *p = sim->get_core(0);
 492   mmu_t* mmu = sim->debug_mmu;
 493   for (unsigned int i = 0; i < length; i++) {
 494     if (iter == packet.end()) {
 495       return send_packet("E22");
 496     }
 497     mmu->store_uint8(address + i, *iter);
 498     iter++;
 499   }
 500   if (*iter != '#')
 501     return send_packet("E4b"); // EOVERFLOW
 502
 503   send_packet("OK");
 504 }
 505
 506 void gdbserver_t::handle_continue(const std::vector<uint8_t> &packet)
 507 {
 508   // c [addr]
 509   processor_t *p = sim->get_core(0);
 510   if (packet[2] != '#') {
 511     std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 512     p->state.pc = consume_hex_number(iter, packet.end());
 513     if (*iter != '#')
 514       return send_packet("E30");
 515   }
 516
 517   p->set_halted(false, HR_NONE);
 518   running = true;
 519 }
 520
 521 void gdbserver_t::handle_step(const std::vector<uint8_t> &packet)
 522 {
 523   // s [addr]
 524   processor_t *p = sim->get_core(0);
 525   if (packet[2] != '#') {
 526     std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 527     p->state.pc = consume_hex_number(iter, packet.end());
 528     if (*iter != '#')
 529       return send_packet("E40");
 530   }
 531
 532   p->set_single_step(true);
 533   running = true;
 534 }
 535
 536 void gdbserver_t::handle_kill(const std::vector<uint8_t> &packet)
 537 {
 538   // k
 539   // The exact effect of this packet is not specified.
 540   // Looks like OpenOCD disconnects?
 541   // TODO
 542 }
 543
 544 void gdbserver_t::handle_extended(const std::vector<uint8_t> &packet)
 545 {
 546   // Enable extended mode. In extended mode, the remote server is made
 547   // persistent. The ‘R’ packet is used to restart the program being debugged.
 548   send_packet("OK");
 549   extended_mode = true;
 550 }
 551
 552 void software_breakpoint_t::insert(mmu_t* mmu)
 553 {
 554   if (size == 2) {
 555     instruction = mmu->load_uint16(address);
 556     mmu->store_uint16(address, C_EBREAK);
 557   } else {
 558     instruction = mmu->load_uint32(address);
 559     mmu->store_uint32(address, EBREAK);
 560   }
 561   fprintf(stderr, ">>> Read %x from %lx\n", instruction, address);
 562 }
 563
 564 void software_breakpoint_t::remove(mmu_t* mmu)
 565 {
 566   fprintf(stderr, ">>> write %x to %lx\n", instruction, address);
 567   if (size == 2) {
 568     mmu->store_uint16(address, instruction);
 569   } else {
 570     mmu->store_uint32(address, instruction);
 571   }
 572 }
 573
 574 void gdbserver_t::handle_breakpoint(const std::vector<uint8_t> &packet)
 575 {
 576   // insert: Z type,addr,kind
 577   // remove: z type,addr,kind
 578
 579   software_breakpoint_t bp;
 580   bool insert = (packet[1] == 'Z');
 581   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 582   int type = consume_hex_number(iter, packet.end());
 583   if (*iter != ',')
 584     return send_packet("E50");
 585   iter++;
 586   bp.address = consume_hex_number(iter, packet.end());
 587   if (*iter != ',')
 588     return send_packet("E51");
 589   iter++;
 590   bp.size = consume_hex_number(iter, packet.end());
 591   // There may be more options after a ; here, but we don't support that.
 592   if (*iter != '#')
 593     return send_packet("E52");
 594
 595   if (bp.size != 2 && bp.size != 4) {
 596     return send_packet("E53");
 597   }
 598
 599   processor_t *p = sim->get_core(0);
 600   mmu_t* mmu = p->mmu;
 601   if (insert) {
 602     bp.insert(mmu);
 603     breakpoints[bp.address] = bp;
 604
 605   } else {
 606     bp = breakpoints[bp.address];
 607     bp.remove(mmu);
 608     breakpoints.erase(bp.address);
 609   }
 610   mmu->flush_icache();
 611   sim->debug_mmu->flush_icache();
 612   return send_packet("OK");
 613 }
 614
 615 void gdbserver_t::handle_query(const std::vector<uint8_t> &packet)
 616 {
 617   std::string name;
 618   std::vector<uint8_t>::const_iterator iter = packet.begin() + 2;
 619
 620   consume_string(name, iter, packet.end(), ':');
 621   if (iter != packet.end())
 622     iter++;
 623   if (name == "Supported") {
 624     send("$");
 625     running_checksum = 0;
 626     while (iter != packet.end()) {
 627       std::string feature;
 628       consume_string(feature, iter, packet.end(), ';');
 629       if (iter != packet.end())
 630         iter++;
 631       if (feature == "swbreak+") {
 632         send("swbreak+;");
 633       }
 634     }
 635     return send_running_checksum();
 636   }
 637
 638   fprintf(stderr, "Unsupported query %s\n", name.c_str());
 639   return send_packet("");
 640 }
 641
 642 void gdbserver_t::handle_packet(const std::vector<uint8_t> &packet)
 643 {
 644   if (compute_checksum(packet) != extract_checksum(packet)) {
 645     fprintf(stderr, "Received %ld-byte packet with invalid checksum\n", packet.size());
 646     fprintf(stderr, "Computed checksum: %x\n", compute_checksum(packet));
 647     print_packet(packet);
 648     send("-");
 649     return;
 650   }
 651
 652   fprintf(stderr, "Received %ld-byte packet from debug client: ", packet.size());
 653   print_packet(packet);
 654   send("+");
 655
 656   switch (packet[1]) {
 657     case '!':
 658       return handle_extended(packet);
 659     case '?':
 660       return handle_halt_reason(packet);
 661     case 'g':
 662       return handle_general_registers_read(packet);
 663     case 'k':
 664       return handle_kill(packet);
 665     case 'm':
 666       return handle_memory_read(packet);
 667 //    case 'M':
 668 //      return handle_memory_write(packet);
 669     case 'X':
 670       return handle_memory_binary_write(packet);
 671     case 'p':
 672       return handle_register_read(packet);
 673     case 'P':
 674       return handle_register_write(packet);
 675     case 'c':
 676       return handle_continue(packet);
 677     case 's':
 678       return handle_step(packet);
 679     case 'z':
 680     case 'Z':
 681       return handle_breakpoint(packet);
 682     case 'q':
 683     case 'Q':
 684       return handle_query(packet);
 685   }
 686
 687   // Not supported.
 688   fprintf(stderr, "** Unsupported packet: ");
 689   print_packet(packet);
 690   send_packet("");
 691 }
 692
 693 void gdbserver_t::handle_interrupt()
 694 {
 695   processor_t *p = sim->get_core(0);
 696   p->set_halted(true, HR_INTERRUPT);
 697   send_packet("S02");   // Pretend program received SIGINT.
 698   running = false;
 699 }
 700
 701 void gdbserver_t::handle()
 702 {
 703   processor_t *p = sim->get_core(0);
 704   if (running && p->halted) {
 705     // The core was running, but now it's halted. Better tell gdb.
 706     switch (p->halt_reason) {
 707       case HR_NONE:
 708         fprintf(stderr, "Internal error. Processor halted without reason.\n");
 709         abort();
 710       case HR_STEPPED:
 711       case HR_INTERRUPT:
 712       case HR_CMDLINE:
 713       case HR_ATTACHED:
 714         // There's no gdb code for this.
 715         send_packet("T05");
 716         break;
 717       case HR_SWBP:
 718         send_packet("T05swbreak:;");
 719         break;
 720     }
 721     send_packet("T00");
 722     // TODO: Actually include register values here
 723     running = false;
 724   }
 725
 726   if (client_fd > 0) {
 727     this->read();
 728     this->write();
 729
 730   } else {
 731     this->accept();
 732   }
 733
 734   this->process_requests();
 735 }
 736
 737 void gdbserver_t::send(const char* msg)
 738 {
 739   unsigned int length = strlen(msg);
 740   for (const char *c = msg; *c; c++)
 741     running_checksum += *c;
 742   send_buf.append((const uint8_t *) msg, length);
 743 }
 744
 745 void gdbserver_t::send(uint64_t value)
 746 {
 747   char buffer[3];
 748   for (unsigned int i = 0; i < 8; i++) {
 749     sprintf(buffer, "%02x", (int) (value & 0xff));
 750     send(buffer);
 751     value >>= 8;
 752   }
 753 }
 754
 755 void gdbserver_t::send(uint32_t value)
 756 {
 757   char buffer[3];
 758   for (unsigned int i = 0; i < 4; i++) {
 759     sprintf(buffer, "%02x", (int) (value & 0xff));
 760     send(buffer);
 761     value >>= 8;
 762   }
 763 }
 764
 765 void gdbserver_t::send_packet(const char* data)
 766 {
 767   send("$");
 768   running_checksum = 0;
 769   send(data);
 770   send_running_checksum();
 771   expect_ack = true;
 772 }
 773
 774 void gdbserver_t::send_running_checksum()
 775 {
 776   char checksum_string[4];
 777   sprintf(checksum_string, "#%02x", running_checksum);
 778   send(checksum_string);
 779 }