sid/component/gdb/gdbserv-state.c

   1 /*
   2  * gdbserv-state.c -- part of GDB remote server
   3  *
   4  * Copyright (C) 2000, 2002, 2006 Red Hat.
   5  * This file is part of SID and is licensed under the GPL.
   6  * See the file COPYING.SID for conditions for redistribution.
   7  */
   8
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12
  13 #include "gdbserv.h"
  14 #include "gdbserv-state.h"
  15 #include "gdbserv-utils.h"
  16
  17 FILE *gdbserv_state_trace = NULL;
  18
  19 static const char *
  20 state2str (struct gdbserv *gdbserv)
  21 {
  22   switch (gdbserv->state)
  23     {
  24     case GDBSERV_STATE_UNINITIALIZED: return "UNINITIALIZED";
  25     case GDBSERV_STATE_RESETTING: return "RESETTING";
  26     case GDBSERV_STATE_STUMBLING: return "STUMBLING";
  27     case GDBSERV_STATE_STEPPING: return "STEPPING";
  28     case GDBSERV_STATE_RUNNING: return "RUNNING";
  29     case GDBSERV_STATE_BROKEN: return "BROKEN";
  30     case GDBSERV_STATE_EXITING: return "EXITING";
  31     case GDBSERV_STATE_EXITED: return "EXITED";
  32     }
  33   return "?";
  34 }
  35
  36 void *
  37 gdbserv_client_data (struct gdbserv *gdbserv)
  38 {
  39   return gdbserv->client->data;
  40 }
  41
  42 void *
  43 gdbserv_target_data (struct gdbserv *gdbserv)
  44 {
  45   return gdbserv->target->data;
  46 }
  47
  48 struct gdbserv *
  49 gdbserv_fromclient_attach (struct gdbserv_client *gdbclient,
  50                            gdbserv_target_attach *to_target_attach,
  51                            void *target_attach_data)
  52 {
  53   struct gdbserv *gdbserv = malloc (sizeof (struct gdbserv));
  54   if (gdbserv_state_trace)
  55     fprintf (gdbserv_state_trace, "<gdbserv_fromclient_attach %s>\n",
  56              state2str (gdbserv));
  57   gdbserv->client = gdbclient;
  58   gdbserv_input_attach (gdbserv);
  59   gdbserv_output_attach (gdbserv);
  60   gdbserv->target = to_target_attach (gdbserv, target_attach_data);
  61   if (gdbserv->target == NULL)
  62     {
  63       gdbserv_output_detach (gdbserv);
  64       gdbserv_input_detach (gdbserv);
  65       free (gdbserv);
  66       return NULL;
  67     }
  68   else
  69     {
  70       gdbserv->state = GDBSERV_STATE_RESETTING;
  71       return gdbserv;
  72     }
  73 }
  74
  75 void
  76 gdbserv_fromclient_detach (struct gdbserv *gdbserv)
  77 {
  78   if (gdbserv_state_trace)
  79     fprintf (gdbserv_state_trace, "<gdbserv_fromclient_detach %s>\n",
  80              state2str (gdbserv));
  81   gdbserv->target->detach (gdbserv);
  82   gdbserv_input_detach (gdbserv);
  83   gdbserv_output_detach (gdbserv);
  84   free (gdbserv);
  85 }
  86
  87
  88 void
  89 gdbserv_fromclient_break (struct gdbserv *gdbserv)
  90 {
  91   if (gdbserv_state_trace)
  92     fprintf (gdbserv_state_trace, "<gdbserv_fromclient_break %s>\n",
  93              state2str (gdbserv));
  94   switch (gdbserv->state)
  95     {
  96     case GDBSERV_STATE_RUNNING:
  97     case GDBSERV_STATE_STEPPING:
  98     case GDBSERV_STATE_STUMBLING:
  99       gdbserv->target->break_program (gdbserv);
 100       /* NOTE: no state change - we might break the program at the
 101          same time as it stops itself */
 102       break;
 103     default:
 104       ;
 105     }
 106 }
 107
 108
 109 void
 110 gdbserv_fromclient_data (struct gdbserv *gdbserv,
 111                          const char *buf,
 112                          int len)
 113 {
 114 #if 0
 115   if (gdbserv_state_trace)
 116     fprintf (gdbserv_state_trace, "<gdbserv_fromclient_data %s>\n",
 117              state2str (gdbserv));
 118 #endif
 119   gdbserv_input_data_packet (gdbserv, buf, len);
 120 }
 121
 122
 123 void
 124 gdbserv_data_packet (struct gdbserv *gdbserv)
 125 {
 126   const char *exec_direction = "forward";
 127   char packet_type = gdbserv_input_char (gdbserv);
 128   if (gdbserv_state_trace)
 129     fprintf (gdbserv_state_trace, "<gdbserv_data_packet:%c>\n", packet_type);
 130
 131   /* NB: default is for this to send an empty packet */
 132
 133   /* Check for a 'b' (backward) prefix for S, s, C and c.  This indicates that
 134      the direction of execution is to be backward.  */
 135   if (packet_type == 'b')
 136     {
 137       char next = gdbserv_input_peek (gdbserv);
 138       switch (next)
 139         {
 140         case 'S': case 's': case 'C': case 'c':
 141           exec_direction = "backward";
 142           packet_type = gdbserv_input_char (gdbserv);
 143           break;
 144         default:
 145           break;
 146         }
 147     }
 148
 149   switch (packet_type)
 150     {
 151
 152     case '?':
 153       {
 154         unsigned long sigval = gdbserv->target->compute_signal (gdbserv, gdbserv->target->get_trap_number (gdbserv));
 155         gdbserv_output_char (gdbserv, 'S');
 156         gdbserv_output_byte (gdbserv, sigval);
 157         break;
 158       }
 159
 160     case 'd': /* toggle debug flag */
 161       gdbserv_output_string (gdbserv, "");
 162       break;
 163
 164     case 'q': /* general query packet */
 165       if (gdbserv_input_string_match (gdbserv, "Rcmd,") >= 0
 166           && gdbserv->target->process_rcmd)
 167         {
 168           /* Format: qRcmd,<hex-encoded-command> */
 169           char *cmd;
 170           int sizeof_cmd;
 171           /* create a buffer sufficent to hold the decoded
 172              command. There are two hex digits per encoded byte. */
 173           sizeof_cmd = gdbserv_input_size (gdbserv) / 2;
 174           if (sizeof_cmd < 0)
 175             {
 176               gdbserv_output_string (gdbserv, "E11");
 177               break;
 178             }
 179           cmd = alloca (sizeof_cmd + 1);
 180           /* Decode/read the command into the buffer, check that the
 181              command exactly fits - not to many, not to few bytes of
 182              input. */
 183           if (gdbserv_input_bytes (gdbserv, cmd, sizeof_cmd) < sizeof_cmd
 184               || gdbserv_input_size (gdbserv) != 0)
 185             {
 186               gdbserv_output_string (gdbserv, "E12");
 187               break;
 188             }
 189           /* Process the command.  Guarentee that that it is NUL
 190              terminated. */
 191           cmd[sizeof_cmd] = '\0';
 192           gdbserv->target->process_rcmd (gdbserv, cmd, sizeof_cmd);
 193         }
 194       else if (gdbserv->target->process_get_gen)
 195         {
 196           gdbserv->target->process_get_gen (gdbserv);
 197         }
 198       else
 199         {
 200           if (gdbserv_state_trace)
 201             fprintf (gdbserv_state_trace, "<general_query>\n");
 202         }
 203       break;
 204
 205     case 'Q': /* general set packet */
 206       if (gdbserv->target->process_set_gen)
 207         gdbserv->target->process_set_gen (gdbserv);
 208       else
 209         {
 210           if (gdbserv_state_trace)
 211             fprintf (gdbserv_state_trace, "<general_set>\n");
 212         }
 213       break;
 214
 215     case 'g': /* return the value of the CPU registers. */
 216       if (gdbserv->target->gg_reg_nr != NULL
 217           && gdbserv->target->get_reg != NULL
 218           && gdbserv->target->sizeof_reg != NULL
 219           && gdbserv->target->output_reg != NULL)
 220         {
 221           int i;
 222           int reg_nr;
 223           for (i = 0, reg_nr = gdbserv->target->gg_reg_nr (gdbserv, i);
 224                reg_nr >= 0;
 225                i++, reg_nr = gdbserv->target->gg_reg_nr (gdbserv, i))
 226             {
 227               struct gdbserv_reg reg;
 228               long sizeof_reg = gdbserv->target->sizeof_reg (gdbserv, reg_nr);
 229               long len = (sizeof_reg < 0 ? -sizeof_reg : sizeof_reg);
 230               if (sizeof_reg > 0)
 231                 gdbserv->target->get_reg (gdbserv, reg_nr, &reg);
 232               else
 233                 memset (&reg, sizeof (reg), 0);
 234               gdbserv->target->output_reg (gdbserv, &reg, len);
 235             }
 236         }
 237       else if (gdbserv->target->process_get_regs != NULL)
 238         {
 239           gdbserv->target->process_get_regs (gdbserv);
 240         }
 241       break;
 242
 243     case 'G': /* set the value of the CPU registers - return OK */
 244       if (gdbserv->target->gg_reg_nr != NULL
 245           && gdbserv->target->set_reg != NULL
 246           && gdbserv->target->sizeof_reg != NULL
 247           && gdbserv->target->input_reg != NULL)
 248         {
 249           int i;
 250           int reg_nr;
 251           for (i = 0, reg_nr = gdbserv->target->gg_reg_nr (gdbserv, i);
 252                reg_nr >= 0;
 253                i++, reg_nr = gdbserv->target->gg_reg_nr (gdbserv, i))
 254             {
 255               struct gdbserv_reg reg;
 256               long sizeof_reg = gdbserv->target->sizeof_reg (gdbserv, reg_nr);
 257               long len = (sizeof_reg < 0 ? -sizeof_reg : sizeof_reg);
 258               gdbserv->target->input_reg (gdbserv, &reg, len);
 259               if (sizeof_reg > 0)
 260                 /* only supply registers that are useful. */
 261                 gdbserv->target->set_reg (gdbserv, reg_nr, &reg);
 262             }
 263           gdbserv_output_string (gdbserv, "OK");
 264         }
 265       else if (gdbserv->target->process_set_regs != NULL)
 266         {
 267           gdbserv->target->process_set_regs (gdbserv);
 268         }
 269       break;
 270
 271     case 'A': /* UNOFFICIAL: set program arguments */
 272       gdbserv->target->process_set_args (gdbserv);
 273       break;
 274
 275 #if 0
 276     case 'p': /* UNOFFICIAL/BROKEN: read single reg */
 277       {
 278         char *ptr = &packet[1];
 279         unsigned long regnr;
 280         struct gdbserv_reg reg;
 281         if (__gdbserv_hex_to_ulong (&ptr, &regnr)
 282             && *ptr++ == '\0'
 283             && gdbserv->target->process_get_reg (gdbserv, regnr, &reg))
 284           {
 285             /* FIXME: Return single register */
 286             gdbserv_output_string (gdbserv, "P01");
 287           }
 288         else
 289           {
 290             gdbserv_output_string (gdbserv, "P01");
 291           }
 292         break;
 293       }
 294 #endif
 295
 296     case 'P': /* write single reg */
 297       if (gdbserv->target->set_reg != NULL
 298           && gdbserv->target->input_reg != NULL)
 299         {
 300           unsigned long regnr;
 301           struct gdbserv_reg reg;
 302           if (gdbserv_input_hex_ulong (gdbserv, &regnr) < 0)
 303             {
 304               gdbserv_output_string (gdbserv, "E01");
 305             }
 306           else if (gdbserv_input_char (gdbserv) != '=')
 307             {
 308               gdbserv_output_string (gdbserv, "E02");
 309             }
 310           else if (gdbserv->target->input_reg (gdbserv, &reg, 0) < 0)
 311             {
 312               gdbserv_output_string (gdbserv, "E03");
 313             }
 314           else
 315             {
 316               gdbserv->target->set_reg (gdbserv, regnr, &reg);
 317               gdbserv_output_string (gdbserv, "OK");
 318             }
 319         }
 320       else if (gdbserv->target->process_set_reg != NULL)
 321         {
 322           unsigned long regnr;
 323           if (gdbserv_input_hex_ulong (gdbserv, &regnr) < 0)
 324             {
 325               gdbserv_output_string (gdbserv, "E01");
 326             }
 327           else if (gdbserv_input_char (gdbserv) != '=')
 328             {
 329               gdbserv_output_string (gdbserv, "E02");
 330             }
 331           else if (gdbserv->target->process_set_reg (gdbserv, regnr) < 0)
 332             {
 333               gdbserv_output_string (gdbserv, "E03");
 334             }
 335           else
 336             {
 337               gdbserv_output_string (gdbserv, "OK");
 338             }
 339         }
 340       break;
 341
 342     case 'm': /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
 343     case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
 344     case 'X': /* XAA..AA,LLLL: Write LLLL binary bytes at AA.AA return OK */
 345       if ((packet_type == 'm' && gdbserv->target->get_mem != NULL)
 346           || ((packet_type == 'M' || packet_type == 'X')
 347               && gdbserv->target->set_mem != NULL))
 348         {
 349           struct gdbserv_reg addr;
 350           long len;
 351           if (gdbserv_input_reg_beb (gdbserv, &addr, 0) < 0)
 352             {
 353               gdbserv_output_string (gdbserv, "E01");
 354             }
 355           else if (gdbserv_input_char (gdbserv) != ',')
 356             {
 357               gdbserv_output_string (gdbserv, "E02");
 358             }
 359           else if (gdbserv_input_hex_ulong (gdbserv, &len) < 0)
 360             {
 361               gdbserv_output_string (gdbserv, "E03");
 362             }
 363           else if (packet_type == 'm')
 364             {
 365               void *data = alloca (len);
 366               long nr_read = gdbserv->target->get_mem (gdbserv, &addr, data, len);
 367               gdbserv_output_bytes (gdbserv, data, nr_read);
 368             }
 369           else if (gdbserv_input_char (gdbserv) == ':')
 370             {
 371               if (packet_type == 'X')
 372                 {
 373                   void *data = alloca (len);
 374                   if (gdbserv_input_escaped_binary (gdbserv, data, len) != len)
 375                     gdbserv_output_string (gdbserv, "E05");
 376                   else if (gdbserv->target->set_mem (gdbserv, &addr, data, len) != len)
 377                     gdbserv_output_string (gdbserv, "E07");
 378                   else
 379                     gdbserv_output_string (gdbserv, "OK");
 380                 }
 381               else
 382                 {
 383                   void *data = alloca (len);
 384                   if (gdbserv_input_bytes (gdbserv, data, len) != len)
 385                     gdbserv_output_string (gdbserv, "E06");
 386                   else if (gdbserv->target->set_mem (gdbserv, &addr, data, len) != len)
 387                     gdbserv_output_string (gdbserv, "E09");
 388                   else
 389                     gdbserv_output_string (gdbserv, "OK");
 390                 }
 391               gdbserv_output_string (gdbserv, "OK");
 392             }
 393           else
 394             {
 395               gdbserv_output_string (gdbserv, "E04");
 396             }
 397         }
 398       /* Deprecated / SID Interface. */
 399       else if ((packet_type == 'm'
 400                 && gdbserv->target->process_get_mem != NULL)
 401                || ((packet_type == 'M' || packet_type == 'X')
 402                    && gdbserv->target->process_set_mem != NULL))
 403         {
 404           struct gdbserv_reg addr;
 405           struct gdbserv_reg len;
 406           if (gdbserv_input_reg_beb (gdbserv, &addr, 0) < 0)
 407             {
 408               gdbserv_output_string (gdbserv, "E01");
 409             }
 410           else if (gdbserv_input_char (gdbserv) != ',')
 411             {
 412               gdbserv_output_string (gdbserv, "E02");
 413             }
 414           else if (gdbserv_input_reg_beb (gdbserv, &len, 0) < 0)
 415             {
 416               gdbserv_output_string (gdbserv, "E03");
 417             }
 418           else if (packet_type == 'm')
 419             {
 420               gdbserv->target->process_get_mem (gdbserv, &addr, &len);
 421             }
 422           else if (gdbserv_input_char (gdbserv) == ':')
 423             {
 424               if (packet_type == 'X')
 425                 gdbserv->target->process_set_mem (gdbserv, &addr, &len, 1);
 426               else
 427                 gdbserv->target->process_set_mem (gdbserv, &addr, &len, 0);
 428               gdbserv_output_string (gdbserv, "OK");
 429             }
 430           else
 431             {
 432               gdbserv_output_string (gdbserv, "E04");
 433             }
 434         }
 435       break;
 436
 437     case 'S':
 438     case 's':    /* sAA..AA    Step from address AA..AA(optional) */
 439     case 'C':
 440     case 'c':    /* cAA..AA    Continue at address AA..AA(optional) */
 441       /* try to read optional parameter, pc unchanged if no parm */
 442
 443       {
 444         struct gdbserv_reg addr;
 445         unsigned long sigval = 0;
 446
 447         if (packet_type == 'C' || packet_type == 'S')
 448           {
 449             gdbserv_input_hex_ulong (gdbserv, &sigval);
 450             if (gdbserv_input_peek (gdbserv) == ';')
 451               gdbserv_input_char (gdbserv);
 452           }
 453
 454         // If there was a first address argument, set it as as the PC
 455         if (gdbserv_input_reg_beb (gdbserv, &addr, 0) >= 0)
 456           gdbserv->target->process_set_pc (gdbserv, &addr);
 457
 458         /* Need to flush the instruction cache here, as we may have
 459            deposited a breakpoint, and the icache probably has no way of
 460            knowing that a data ref to some location may have changed
 461            something that is in the instruction cache.  */
 462
 463         gdbserv->target->flush_i_cache (gdbserv);
 464
 465         /* If we have a function to handle signals, call it. */
 466         if (sigval != 0 && gdbserv->target->process_signal != NULL)
 467           {
 468             /* If 0 is returned, we either ignored the signal or invoked a user
 469                handler. Otherwise, the user program should die. */
 470             if (! gdbserv->target->process_signal (gdbserv, sigval))
 471               sigval = 0;
 472           }
 473
 474         /* if we didn't have a function to handle signals, nuke the
 475            target program */
 476         if (sigval != 0)
 477           {
 478             gdbserv->target->sigkill_program (gdbserv);
 479             return;
 480           }
 481
 482         /* Set the direction.  */
 483         gdbserv->target->set_exec_direction (gdbserv, exec_direction);
 484
 485         /* Set machine state to force a single step.  */
 486         if (packet_type == 's' || packet_type == 'S')
 487           {
 488             gdbserv->target->singlestep_program (gdbserv);
 489             gdbserv->state = GDBSERV_STATE_STEPPING;
 490           }
 491         else
 492           {
 493             gdbserv->target->continue_program (gdbserv);
 494             gdbserv->state = GDBSERV_STATE_RUNNING;
 495           }
 496         return;
 497       }
 498
 499     case 'E':
 500     case 'e':    /* eAA..AA,BB..BB   Step out of address range [AA .. BB) */
 501       /* try to read optional parameter, pc unchanged if no parm */
 502
 503       {
 504         struct gdbserv_reg addr;
 505         struct gdbserv_reg addr_limit;
 506         unsigned long sigval = 0;
 507         int rc;
 508
 509         if (packet_type == 'E')
 510           {
 511             gdbserv_input_hex_ulong (gdbserv, &sigval);
 512             if (gdbserv_input_peek (gdbserv) == ',')
 513               gdbserv_input_char (gdbserv);
 514           }
 515
 516         if (gdbserv_input_reg_beb (gdbserv, &addr, 0) < 0)
 517           {
 518             gdbserv_output_string (gdbserv, "E01");
 519             break;
 520           }
 521
 522         if (gdbserv_input_peek (gdbserv) == ',')
 523           gdbserv_input_char (gdbserv);
 524
 525         if (gdbserv_input_reg_beb (gdbserv, &addr_limit, 0) < 0)
 526           {
 527             gdbserv_output_string (gdbserv, "E02");
 528             break;
 529           }
 530
 531         gdbserv->target->flush_i_cache (gdbserv);
 532
 533         /* If we have a function to handle signals, call it. */
 534         if (sigval != 0 && gdbserv->target->process_signal != NULL)
 535           {
 536             /* If 0 is returned, we either ignored the signal or invoked a user
 537                handler. Otherwise, the user program should die. */
 538             if (! gdbserv->target->process_signal (gdbserv, sigval))
 539               sigval = 0;
 540           }
 541
 542         /* if we didn't have a function to handle signals, nuke the
 543            target program */
 544         if (sigval != 0)
 545           {
 546             gdbserv->target->sigkill_program (gdbserv);
 547             return;
 548           }
 549
 550         rc = gdbserv->target->rangestep_program (gdbserv, & addr, & addr_limit);
 551         if (rc == GDBSERV_TARGET_RC_OK)
 552           {
 553             gdbserv->state = GDBSERV_STATE_RUNNING;
 554             gdbserv_output_string (gdbserv, "OK");
 555           }
 556         else
 557           {
 558             gdbserv_output_string (gdbserv, ""); /* act as if unsupported */
 559           }
 560
 561         break;
 562       }
 563
 564     /* kill the program */
 565     case 'k' :
 566       {
 567         gdbserv->target->exit_program (gdbserv);
 568         gdbserv->state = GDBSERV_STATE_EXITING;
 569         return;
 570       }
 571
 572     case 'Z':
 573     case 'z':
 574       /* breakpoint [Zz]<type>,<address>,<length> */
 575       if (gdbserv->target->remove_breakpoint != NULL
 576           && gdbserv->target->set_breakpoint != NULL)
 577         {
 578           enum gdbserv_target_bp bp;
 579           enum gdbserv_target_rc rc;
 580           unsigned long type;
 581           struct gdbserv_reg addr;
 582           struct gdbserv_reg len;
 583           if (gdbserv_input_hex_ulong (gdbserv, &type) < 0
 584               || gdbserv_input_char (gdbserv) != ','
 585               || gdbserv_input_reg_beb (gdbserv, &addr, 0) < 0
 586               || gdbserv_input_char (gdbserv) != ','
 587               || gdbserv_input_reg_beb (gdbserv, &len, 0) < 0)
 588             {
 589               /* Signal parse error */
 590               gdbserv_output_string (gdbserv, "E01");
 591               break;
 592             }
 593           switch (type)
 594             {
 595             case 0: bp = GDBSERV_TARGET_BP_SOFTWARE; break;
 596             case 1: bp = GDBSERV_TARGET_BP_HARDWARE; break;
 597             case 2: bp = GDBSERV_TARGET_BP_WRITE; break;
 598             case 3: bp = GDBSERV_TARGET_BP_READ; break;
 599             case 4: bp = GDBSERV_TARGET_BP_ACCESS; break;
 600             default: bp = GDBSERV_TARGET_BP_UNKNOWN; break;
 601             }
 602           if (bp == GDBSERV_TARGET_BP_UNKNOWN)
 603             {
 604               /* only recognize software breakpoints */
 605               gdbserv_output_string (gdbserv, "E02");
 606               break;
 607             }
 608           if (packet_type == 'z')
 609             rc = gdbserv->target->remove_breakpoint (gdbserv, bp, &addr, &len);
 610           else
 611             rc = gdbserv->target->set_breakpoint (gdbserv, bp, &addr, &len);
 612           switch (rc)
 613             {
 614             case GDBSERV_TARGET_RC_OK:
 615               gdbserv_output_string (gdbserv, "OK");
 616               break;
 617             case GDBSERV_TARGET_RC_ERROR:
 618               gdbserv_output_string (gdbserv, "E03");
 619               break;
 620             case GDBSERV_TARGET_RC_UNKNOWN:
 621               /* Behave as if operation isn't supported. */
 622               break;
 623             }
 624         }
 625       break;
 626
 627
 628     case 'r':           /* Reset */
 629       if (gdbserv->target->reset_program)
 630         {
 631           gdbserv->target->reset_program (gdbserv);
 632           gdbserv->state = GDBSERV_STATE_RESETTING;
 633         }
 634       gdbserv_output_string (gdbserv, "");
 635       break;
 636
 637
 638     case 'R': /* Rnn restart server */
 639       if (gdbserv->target->restart_program)
 640         {
 641           gdbserv->target->restart_program (gdbserv);
 642           gdbserv->state = GDBSERV_STATE_RESETTING;
 643           return;
 644         }
 645       else
 646         {
 647           gdbserv_output_string (gdbserv, "");
 648         }
 649       break;
 650
 651
 652     case 'i':
 653       /* cycle-step [ <addr> ] [ "," <nnn> ] */
 654       if (gdbserv->target->cyclestep_program)
 655         {
 656           gdbserv->target->cyclestep_program (gdbserv);
 657           gdbserv->state = GDBSERV_STATE_STEPPING;
 658           return;
 659         }
 660       gdbserv_output_string (gdbserv, "");
 661       break;
 662
 663
 664     default:
 665       if (gdbserv->target->process_target_packet)
 666         gdbserv->target->process_target_packet (gdbserv);
 667       else
 668         {
 669           if (gdbserv_state_trace)
 670             fprintf (gdbserv_state_trace, "<target_packet>\n");
 671           gdbserv_output_string (gdbserv, "");
 672         }
 673       break;
 674
 675     }
 676   gdbserv_output_packet (gdbserv);
 677 }
 678
 679 void
 680 gdbserv_fromtarget_reset (struct gdbserv *gdbserv)
 681 {
 682   enum gdbserv_state nextstate;
 683   if (gdbserv_state_trace)
 684     fprintf (gdbserv_state_trace, "<gdbserv_fromtarget_reset %s>\n",
 685              state2str (gdbserv));
 686   switch (gdbserv->state)
 687     {
 688     case GDBSERV_STATE_RESETTING:
 689       /* After a reset / power-on GDB is always expecting the remote
 690          target to stop and receive further commands.  Hence NO NOTIFY
 691          and SINGLESTEP */
 692       gdbserv->target->singlestep_program (gdbserv);
 693       nextstate = GDBSERV_STATE_STUMBLING;
 694       break;
 695     default:
 696       nextstate = gdbserv->state;
 697     }
 698   gdbserv->state = nextstate;
 699 }
 700
 701 void
 702 gdbserv_fromtarget_break (struct gdbserv *gdbserv,
 703                           int sigval)
 704 {
 705   enum gdbserv_state nextstate;
 706   if (gdbserv_state_trace)
 707     fprintf (gdbserv_state_trace, "<gdbserv_fromtarget_break %s>\n",
 708              state2str (gdbserv));
 709   switch (gdbserv->state)
 710     {
 711     case GDBSERV_STATE_STUMBLING:
 712       /* Server has gone through a reset.  GDB expects the client to
 713          be ready for further commands */
 714       nextstate = GDBSERV_STATE_BROKEN;
 715       break;
 716     case GDBSERV_STATE_RUNNING:
 717     case GDBSERV_STATE_STEPPING:
 718       gdbserv_output_discard (gdbserv);
 719       gdbserv_output_char (gdbserv, 'T');
 720       gdbserv_output_byte (gdbserv, sigval);
 721       /* When the target knows how, expedite the supply of register
 722          values back to GDB.  Do this by appending them to the end of
 723          the T packet response. */
 724       if (gdbserv->target->expedited_reg_nr != NULL
 725           && gdbserv->target->get_reg != NULL
 726           && gdbserv->target->output_reg != NULL)
 727         {
 728           int i;
 729           int reg_nr;
 730           for (i = 0, reg_nr = gdbserv->target->expedited_reg_nr (gdbserv, i);
 731                reg_nr >= 0;
 732                i++, reg_nr = gdbserv->target->expedited_reg_nr (gdbserv, i))
 733             {
 734               struct gdbserv_reg reg;
 735               gdbserv_output_char (gdbserv, ';');
 736               gdbserv_output_byte (gdbserv, reg_nr);
 737               gdbserv_output_char (gdbserv, ':');
 738               gdbserv->target->get_reg (gdbserv, reg_nr, &reg);
 739               gdbserv->target->output_reg (gdbserv, &reg, 0);
 740             }
 741           gdbserv_output_char (gdbserv, ';');
 742         }
 743       /* Deprecated / SID Interface. */
 744       else if (gdbserv->target->process_get_exp_regs)
 745         gdbserv->target->process_get_exp_regs (gdbserv);
 746       gdbserv_output_packet (gdbserv);
 747       nextstate = GDBSERV_STATE_BROKEN;
 748       break;
 749     default:
 750       nextstate = gdbserv->state;
 751     }
 752   gdbserv->state = nextstate;
 753 }
 754
 755 void
 756 gdbserv_fromtarget_exit (struct gdbserv *gdbserv,
 757                          int sigval)
 758 {
 759   enum gdbserv_state nextstate;
 760   if (gdbserv_state_trace)
 761     fprintf (gdbserv_state_trace, "<gdbserv_fromtarget_exit %s>\n",
 762              state2str (gdbserv));
 763   switch (gdbserv->state)
 764     {
 765     case GDBSERV_STATE_RUNNING:
 766     case GDBSERV_STATE_STEPPING:
 767       gdbserv_output_char (gdbserv, 'W');
 768       gdbserv_output_byte (gdbserv, sigval);
 769       gdbserv_output_packet (gdbserv);
 770       nextstate = GDBSERV_STATE_EXITED;
 771       break;
 772     default:
 773       nextstate = gdbserv->state;
 774     }
 775   gdbserv->state = nextstate;
 776 }