gdb/i386-stub.c

   1 /****************************************************************************
   2
   3                 THIS SOFTWARE IS NOT COPYRIGHTED
   4
   5    HP offers the following for use in the public domain.  HP makes no
   6    warranty with regard to the software or it's performance and the
   7    user accepts the software "AS IS" with all faults.
   8
   9    HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
  10    TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  11    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 ****************************************************************************/
  14
  15 /****************************************************************************
  16  *  Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
  17  *
  18  *  Module name: remcom.c $
  19  *  Revision: 1.34 $
  20  *  Date: 91/03/09 12:29:49 $
  21  *  Contributor:     Lake Stevens Instrument Division$
  22  *
  23  *  Description:     low level support for gdb debugger. $
  24  *
  25  *  Considerations:  only works on target hardware $
  26  *
  27  *  Written by:      Glenn Engel $
  28  *  ModuleState:     Experimental $
  29  *
  30  *  NOTES:           See Below $
  31  *
  32  *  Modified for 386 by Jim Kingdon, Cygnus Support.
  33  *
  34  *  To enable debugger support, two things need to happen.  One, a
  35  *  call to set_debug_traps() is necessary in order to allow any breakpoints
  36  *  or error conditions to be properly intercepted and reported to gdb.
  37  *  Two, a breakpoint needs to be generated to begin communication.  This
  38  *  is most easily accomplished by a call to breakpoint().  Breakpoint()
  39  *  simulates a breakpoint by executing a trap #1.
  40  *
  41  *  The external function exceptionHandler() is
  42  *  used to attach a specific handler to a specific 386 vector number.
  43  *  It should use the same privilege level it runs at.  It should
  44  *  install it as an interrupt gate so that interrupts are masked
  45  *  while the handler runs.
  46  *
  47  *  Because gdb will sometimes write to the stack area to execute function
  48  *  calls, this program cannot rely on using the supervisor stack so it
  49  *  uses it's own stack area reserved in the int array remcomStack.
  50  *
  51  *************
  52  *
  53  *    The following gdb commands are supported:
  54  *
  55  * command          function                               Return value
  56  *
  57  *    g             return the value of the CPU registers  hex data or ENN
  58  *    G             set the value of the CPU registers     OK or ENN
  59  *
  60  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
  61  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
  62  *
  63  *    c             Resume at current address              SNN   ( signal NN)
  64  *    cAA..AA       Continue at address AA..AA             SNN
  65  *
  66  *    s             Step one instruction                   SNN
  67  *    sAA..AA       Step one instruction from AA..AA       SNN
  68  *
  69  *    k             kill
  70  *
  71  *    ?             What was the last sigval ?             SNN   (signal NN)
  72  *
  73  * All commands and responses are sent with a packet which includes a
  74  * checksum.  A packet consists of
  75  *
  76  * $<packet info>#<checksum>.
  77  *
  78  * where
  79  * <packet info> :: <characters representing the command or response>
  80  * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
  81  *
  82  * When a packet is received, it is first acknowledged with either '+' or '-'.
  83  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
  84  *
  85  * Example:
  86  *
  87  * Host:                  Reply:
  88  * $m0,10#2a               +$00010203040506070809101112131415#42
  89  *
  90  ****************************************************************************/
  91
  92 #include <stdio.h>
  93 #include <string.h>
  94
  95 /************************************************************************
  96  *
  97  * external low-level support routines
  98  */
  99
 100 extern void putDebugChar();     /* write a single character      */
 101 extern int getDebugChar();      /* read and return a single char */
 102 extern void exceptionHandler(); /* assign an exception handler   */
 103
 104 /************************************************************************/
 105 /* BUFMAX defines the maximum number of characters in inbound/outbound buffers*/
 106 /* at least NUMREGBYTES*2 are needed for register packets */
 107 #define BUFMAX 400
 108
 109 static char initialized;  /* boolean flag. != 0 means we've been initialized */
 110
 111 int     remote_debug;
 112 /*  debug >  0 prints ill-formed commands in valid packets & checksum errors */
 113
 114 static const char hexchars[]="0123456789abcdef";
 115
 116 /* Number of registers.  */
 117 #define NUMREGS 16
 118
 119 /* Number of bytes of registers.  */
 120 #define NUMREGBYTES (NUMREGS * 4)
 121
 122 enum regnames {EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI,
 123                PC /* also known as eip */,
 124                PS /* also known as eflags */,
 125                CS, SS, DS, ES, FS, GS};
 126
 127 /*
 128  * these should not be static cuz they can be used outside this module
 129  */
 130 int registers[NUMREGS];
 131
 132 #define STACKSIZE 10000
 133 int remcomStack[STACKSIZE/sizeof(int)];
 134 static int* stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];
 135
 136 /***************************  ASSEMBLY CODE MACROS *************************/
 137 /*                                                                         */
 138
 139 extern void
 140 return_to_prog ();
 141
 142 /* Restore the program's registers (including the stack pointer, which
 143    means we get the right stack and don't have to worry about popping our
 144    return address and any stack frames and so on) and return.  */
 145 asm(".text");
 146 asm(".globl _return_to_prog");
 147 asm("_return_to_prog:");
 148 asm("        movw _registers+44, %ss");
 149 asm("        movl _registers+16, %esp");
 150 asm("        movl _registers+4, %ecx");
 151 asm("        movl _registers+8, %edx");
 152 asm("        movl _registers+12, %ebx");
 153 asm("        movl _registers+20, %ebp");
 154 asm("        movl _registers+24, %esi");
 155 asm("        movl _registers+28, %edi");
 156 asm("        movw _registers+48, %ds");
 157 asm("        movw _registers+52, %es");
 158 asm("        movw _registers+56, %fs");
 159 asm("        movw _registers+60, %gs");
 160 asm("        movl _registers+36, %eax");
 161 asm("        pushl %eax");  /* saved eflags */
 162 asm("        movl _registers+40, %eax");
 163 asm("        pushl %eax");  /* saved cs */
 164 asm("        movl _registers+32, %eax");
 165 asm("        pushl %eax");  /* saved eip */
 166 asm("        movl _registers, %eax");
 167 /* use iret to restore pc and flags together so
 168    that trace flag works right.  */
 169 asm("        iret");
 170
 171 #define BREAKPOINT() asm("   int $3");
 172
 173 /* Put the error code here just in case the user cares.  */
 174 int gdb_i386errcode;
 175 /* Likewise, the vector number here (since GDB only gets the signal
 176    number through the usual means, and that's not very specific).  */
 177 int gdb_i386vector = -1;
 178
 179 /* GDB stores segment registers in 32-bit words (that's just the way
 180    m-i386v.h is written).  So zero the appropriate areas in registers.  */
 181 #define SAVE_REGISTERS1() \
 182   asm ("movl %eax, _registers");                                          \
 183   asm ("movl %ecx, _registers+4");                                           \
 184   asm ("movl %edx, _registers+8");                                           \
 185   asm ("movl %ebx, _registers+12");                                          \
 186   asm ("movl %ebp, _registers+20");                                          \
 187   asm ("movl %esi, _registers+24");                                          \
 188   asm ("movl %edi, _registers+28");                                          \
 189   asm ("movw $0, %ax");                                                      \
 190   asm ("movw %ds, _registers+48");                                           \
 191   asm ("movw %ax, _registers+50");                                           \
 192   asm ("movw %es, _registers+52");                                           \
 193   asm ("movw %ax, _registers+54");                                           \
 194   asm ("movw %fs, _registers+56");                                           \
 195   asm ("movw %ax, _registers+58");                                           \
 196   asm ("movw %gs, _registers+60");                                           \
 197   asm ("movw %ax, _registers+62");
 198 #define SAVE_ERRCODE() \
 199   asm ("popl %ebx");                                  \
 200   asm ("movl %ebx, _gdb_i386errcode");
 201 #define SAVE_REGISTERS2() \
 202   asm ("popl %ebx"); /* old eip */                                           \
 203   asm ("movl %ebx, _registers+32");                                          \
 204   asm ("popl %ebx");     /* old cs */                                        \
 205   asm ("movl %ebx, _registers+40");                                          \
 206   asm ("movw %ax, _registers+42");                                           \
 207   asm ("popl %ebx");     /* old eflags */                                    \
 208   asm ("movl %ebx, _registers+36");                                          \
 209   /* Now that we've done the pops, we can save the stack pointer.");  */   \
 210   asm ("movw %ss, _registers+44");                                           \
 211   asm ("movw %ax, _registers+46");                                           \
 212   asm ("movl %esp, _registers+16");
 213
 214 /* See if mem_fault_routine is set, if so just IRET to that address.  */
 215 #define CHECK_FAULT() \
 216   asm ("cmpl $0, _mem_fault_routine");                                     \
 217   asm ("jne mem_fault");
 218
 219 asm (".text");
 220 asm ("mem_fault:");
 221 /* OK to clobber temp registers; we're just going to end up in set_mem_err.  */
 222 /* Pop error code from the stack and save it.  */
 223 asm ("     popl %eax");
 224 asm ("     movl %eax, _gdb_i386errcode");
 225
 226 asm ("     popl %eax"); /* eip */
 227 /* We don't want to return there, we want to return to the function
 228    pointed to by mem_fault_routine instead.  */
 229 asm ("     movl _mem_fault_routine, %eax");
 230 asm ("     popl %ecx"); /* cs (low 16 bits; junk in hi 16 bits).  */
 231 asm ("     popl %edx"); /* eflags */
 232
 233 /* Remove this stack frame; when we do the iret, we will be going to
 234    the start of a function, so we want the stack to look just like it
 235    would after a "call" instruction.  */
 236 asm ("     leave");
 237
 238 /* Push the stuff that iret wants.  */
 239 asm ("     pushl %edx"); /* eflags */
 240 asm ("     pushl %ecx"); /* cs */
 241 asm ("     pushl %eax"); /* eip */
 242
 243 /* Zero mem_fault_routine.  */
 244 asm ("     movl $0, %eax");
 245 asm ("     movl %eax, _mem_fault_routine");
 246
 247 asm ("iret");
 248
 249 #define CALL_HOOK() asm("call _remcomHandler");
 250
 251 /* This function is called when a i386 exception occurs.  It saves
 252  * all the cpu regs in the _registers array, munges the stack a bit,
 253  * and invokes an exception handler (remcom_handler).
 254  *
 255  * stack on entry:                       stack on exit:
 256  *   old eflags                          vector number
 257  *   old cs (zero-filled to 32 bits)
 258  *   old eip
 259  *
 260  */
 261 extern void _catchException3();
 262 asm(".text");
 263 asm(".globl __catchException3");
 264 asm("__catchException3:");
 265 SAVE_REGISTERS1();
 266 SAVE_REGISTERS2();
 267 asm ("pushl $3");
 268 CALL_HOOK();
 269
 270 /* Same thing for exception 1.  */
 271 extern void _catchException1();
 272 asm(".text");
 273 asm(".globl __catchException1");
 274 asm("__catchException1:");
 275 SAVE_REGISTERS1();
 276 SAVE_REGISTERS2();
 277 asm ("pushl $1");
 278 CALL_HOOK();
 279
 280 /* Same thing for exception 0.  */
 281 extern void _catchException0();
 282 asm(".text");
 283 asm(".globl __catchException0");
 284 asm("__catchException0:");
 285 SAVE_REGISTERS1();
 286 SAVE_REGISTERS2();
 287 asm ("pushl $0");
 288 CALL_HOOK();
 289
 290 /* Same thing for exception 4.  */
 291 extern void _catchException4();
 292 asm(".text");
 293 asm(".globl __catchException4");
 294 asm("__catchException4:");
 295 SAVE_REGISTERS1();
 296 SAVE_REGISTERS2();
 297 asm ("pushl $4");
 298 CALL_HOOK();
 299
 300 /* Same thing for exception 5.  */
 301 extern void _catchException5();
 302 asm(".text");
 303 asm(".globl __catchException5");
 304 asm("__catchException5:");
 305 SAVE_REGISTERS1();
 306 SAVE_REGISTERS2();
 307 asm ("pushl $5");
 308 CALL_HOOK();
 309
 310 /* Same thing for exception 6.  */
 311 extern void _catchException6();
 312 asm(".text");
 313 asm(".globl __catchException6");
 314 asm("__catchException6:");
 315 SAVE_REGISTERS1();
 316 SAVE_REGISTERS2();
 317 asm ("pushl $6");
 318 CALL_HOOK();
 319
 320 /* Same thing for exception 7.  */
 321 extern void _catchException7();
 322 asm(".text");
 323 asm(".globl __catchException7");
 324 asm("__catchException7:");
 325 SAVE_REGISTERS1();
 326 SAVE_REGISTERS2();
 327 asm ("pushl $7");
 328 CALL_HOOK();
 329
 330 /* Same thing for exception 8.  */
 331 extern void _catchException8();
 332 asm(".text");
 333 asm(".globl __catchException8");
 334 asm("__catchException8:");
 335 SAVE_REGISTERS1();
 336 SAVE_ERRCODE();
 337 SAVE_REGISTERS2();
 338 asm ("pushl $8");
 339 CALL_HOOK();
 340
 341 /* Same thing for exception 9.  */
 342 extern void _catchException9();
 343 asm(".text");
 344 asm(".globl __catchException9");
 345 asm("__catchException9:");
 346 SAVE_REGISTERS1();
 347 SAVE_REGISTERS2();
 348 asm ("pushl $9");
 349 CALL_HOOK();
 350
 351 /* Same thing for exception 10.  */
 352 extern void _catchException10();
 353 asm(".text");
 354 asm(".globl __catchException10");
 355 asm("__catchException10:");
 356 SAVE_REGISTERS1();
 357 SAVE_ERRCODE();
 358 SAVE_REGISTERS2();
 359 asm ("pushl $10");
 360 CALL_HOOK();
 361
 362 /* Same thing for exception 12.  */
 363 extern void _catchException12();
 364 asm(".text");
 365 asm(".globl __catchException12");
 366 asm("__catchException12:");
 367 SAVE_REGISTERS1();
 368 SAVE_ERRCODE();
 369 SAVE_REGISTERS2();
 370 asm ("pushl $12");
 371 CALL_HOOK();
 372
 373 /* Same thing for exception 16.  */
 374 extern void _catchException16();
 375 asm(".text");
 376 asm(".globl __catchException16");
 377 asm("__catchException16:");
 378 SAVE_REGISTERS1();
 379 SAVE_REGISTERS2();
 380 asm ("pushl $16");
 381 CALL_HOOK();
 382
 383 /* For 13, 11, and 14 we have to deal with the CHECK_FAULT stuff.  */
 384
 385 /* Same thing for exception 13.  */
 386 extern void _catchException13 ();
 387 asm (".text");
 388 asm (".globl __catchException13");
 389 asm ("__catchException13:");
 390 CHECK_FAULT();
 391 SAVE_REGISTERS1();
 392 SAVE_ERRCODE();
 393 SAVE_REGISTERS2();
 394 asm ("pushl $13");
 395 CALL_HOOK();
 396
 397 /* Same thing for exception 11.  */
 398 extern void _catchException11 ();
 399 asm (".text");
 400 asm (".globl __catchException11");
 401 asm ("__catchException11:");
 402 CHECK_FAULT();
 403 SAVE_REGISTERS1();
 404 SAVE_ERRCODE();
 405 SAVE_REGISTERS2();
 406 asm ("pushl $11");
 407 CALL_HOOK();
 408
 409 /* Same thing for exception 14.  */
 410 extern void _catchException14 ();
 411 asm (".text");
 412 asm (".globl __catchException14");
 413 asm ("__catchException14:");
 414 CHECK_FAULT();
 415 SAVE_REGISTERS1();
 416 SAVE_ERRCODE();
 417 SAVE_REGISTERS2();
 418 asm ("pushl $14");
 419 CALL_HOOK();
 420
 421 /*
 422  * remcomHandler is a front end for handle_exception.  It moves the
 423  * stack pointer into an area reserved for debugger use.
 424  */
 425 asm("_remcomHandler:");
 426 asm("           popl %eax");        /* pop off return address     */
 427 asm("           popl %eax");      /* get the exception number   */
 428 asm("           movl _stackPtr, %esp"); /* move to remcom stack area  */
 429 asm("           pushl %eax");   /* push exception onto stack  */
 430 asm("           call  _handle_exception");    /* this never returns */
 431
 432 void
 433 _returnFromException ()
 434 {
 435   return_to_prog ();
 436 }
 437
 438 int
 439 hex (ch)
 440      char ch;
 441 {
 442   if ((ch >= 'a') && (ch <= 'f'))
 443     return (ch - 'a' + 10);
 444   if ((ch >= '0') && (ch <= '9'))
 445     return (ch - '0');
 446   if ((ch >= 'A') && (ch <= 'F'))
 447     return (ch - 'A' + 10);
 448   return (-1);
 449 }
 450
 451 static char remcomInBuffer[BUFMAX];
 452 static char remcomOutBuffer[BUFMAX];
 453
 454 /* scan for the sequence $<data>#<checksum>     */
 455
 456 unsigned char *
 457 getpacket (void)
 458 {
 459   unsigned char *buffer = &remcomInBuffer[0];
 460   unsigned char checksum;
 461   unsigned char xmitcsum;
 462   int count;
 463   char ch;
 464
 465   while (1)
 466     {
 467       /* wait around for the start character, ignore all other characters */
 468       while ((ch = getDebugChar ()) != '$')
 469         ;
 470
 471     retry:
 472       checksum = 0;
 473       xmitcsum = -1;
 474       count = 0;
 475
 476       /* now, read until a # or end of buffer is found */
 477       while (count < BUFMAX - 1)
 478         {
 479           ch = getDebugChar ();
 480           if (ch == '$')
 481             goto retry;
 482           if (ch == '#')
 483             break;
 484           checksum = checksum + ch;
 485           buffer[count] = ch;
 486           count = count + 1;
 487         }
 488       buffer[count] = 0;
 489
 490       if (ch == '#')
 491         {
 492           ch = getDebugChar ();
 493           xmitcsum = hex (ch) << 4;
 494           ch = getDebugChar ();
 495           xmitcsum += hex (ch);
 496
 497           if (checksum != xmitcsum)
 498             {
 499               if (remote_debug)
 500                 {
 501                   fprintf (stderr,
 502                            "bad checksum.  My count = 0x%x, sent=0x%x. buf=%s\n",
 503                            checksum, xmitcsum, buffer);
 504                 }
 505               putDebugChar ('-');       /* failed checksum */
 506             }
 507           else
 508             {
 509               putDebugChar ('+');       /* successful transfer */
 510
 511               /* if a sequence char is present, reply the sequence ID */
 512               if (buffer[2] == ':')
 513                 {
 514                   putDebugChar (buffer[0]);
 515                   putDebugChar (buffer[1]);
 516
 517                   return &buffer[3];
 518                 }
 519
 520               return &buffer[0];
 521             }
 522         }
 523     }
 524 }
 525
 526 /* send the packet in buffer.  */
 527
 528 void
 529 putpacket (unsigned char *buffer)
 530 {
 531   unsigned char checksum;
 532   int count;
 533   char ch;
 534
 535   /*  $<packet info>#<checksum>. */
 536   do
 537     {
 538       putDebugChar ('$');
 539       checksum = 0;
 540       count = 0;
 541
 542       while (ch = buffer[count])
 543         {
 544           putDebugChar (ch);
 545           checksum += ch;
 546           count += 1;
 547         }
 548
 549       putDebugChar ('#');
 550       putDebugChar (hexchars[checksum >> 4]);
 551       putDebugChar (hexchars[checksum % 16]);
 552
 553     }
 554   while (getDebugChar () != '+');
 555 }
 556
 557 void
 558 debug_error (format, parm)
 559      char *format;
 560      char *parm;
 561 {
 562   if (remote_debug)
 563     fprintf (stderr, format, parm);
 564 }
 565
 566 /* Address of a routine to RTE to if we get a memory fault.  */
 567 static void (*volatile mem_fault_routine) () = NULL;
 568
 569 /* Indicate to caller of mem2hex or hex2mem that there has been an
 570    error.  */
 571 static volatile int mem_err = 0;
 572
 573 void
 574 set_mem_err (void)
 575 {
 576   mem_err = 1;
 577 }
 578
 579 /* These are separate functions so that they are so short and sweet
 580    that the compiler won't save any registers (if there is a fault
 581    to mem_fault, they won't get restored, so there better not be any
 582    saved).  */
 583 int
 584 get_char (char *addr)
 585 {
 586   return *addr;
 587 }
 588
 589 void
 590 set_char (char *addr, int val)
 591 {
 592   *addr = val;
 593 }
 594
 595 /* convert the memory pointed to by mem into hex, placing result in buf */
 596 /* return a pointer to the last char put in buf (null) */
 597 /* If MAY_FAULT is non-zero, then we should set mem_err in response to
 598    a fault; if zero treat a fault like any other fault in the stub.  */
 599 char *
 600 mem2hex (mem, buf, count, may_fault)
 601      char *mem;
 602      char *buf;
 603      int count;
 604      int may_fault;
 605 {
 606   int i;
 607   unsigned char ch;
 608
 609   if (may_fault)
 610     mem_fault_routine = set_mem_err;
 611   for (i = 0; i < count; i++)
 612     {
 613       ch = get_char (mem++);
 614       if (may_fault && mem_err)
 615         return (buf);
 616       *buf++ = hexchars[ch >> 4];
 617       *buf++ = hexchars[ch % 16];
 618     }
 619   *buf = 0;
 620   if (may_fault)
 621     mem_fault_routine = NULL;
 622   return (buf);
 623 }
 624
 625 /* convert the hex array pointed to by buf into binary to be placed in mem */
 626 /* return a pointer to the character AFTER the last byte written */
 627 char *
 628 hex2mem (buf, mem, count, may_fault)
 629      char *buf;
 630      char *mem;
 631      int count;
 632      int may_fault;
 633 {
 634   int i;
 635   unsigned char ch;
 636
 637   if (may_fault)
 638     mem_fault_routine = set_mem_err;
 639   for (i = 0; i < count; i++)
 640     {
 641       ch = hex (*buf++) << 4;
 642       ch = ch + hex (*buf++);
 643       set_char (mem++, ch);
 644       if (may_fault && mem_err)
 645         return (mem);
 646     }
 647   if (may_fault)
 648     mem_fault_routine = NULL;
 649   return (mem);
 650 }
 651
 652 /* this function takes the 386 exception vector and attempts to
 653    translate this number into a unix compatible signal value */
 654 int
 655 computeSignal (int exceptionVector)
 656 {
 657   int sigval;
 658   switch (exceptionVector)
 659     {
 660     case 0:
 661       sigval = 8;
 662       break;                    /* divide by zero */
 663     case 1:
 664       sigval = 5;
 665       break;                    /* debug exception */
 666     case 3:
 667       sigval = 5;
 668       break;                    /* breakpoint */
 669     case 4:
 670       sigval = 16;
 671       break;                    /* into instruction (overflow) */
 672     case 5:
 673       sigval = 16;
 674       break;                    /* bound instruction */
 675     case 6:
 676       sigval = 4;
 677       break;                    /* Invalid opcode */
 678     case 7:
 679       sigval = 8;
 680       break;                    /* coprocessor not available */
 681     case 8:
 682       sigval = 7;
 683       break;                    /* double fault */
 684     case 9:
 685       sigval = 11;
 686       break;                    /* coprocessor segment overrun */
 687     case 10:
 688       sigval = 11;
 689       break;                    /* Invalid TSS */
 690     case 11:
 691       sigval = 11;
 692       break;                    /* Segment not present */
 693     case 12:
 694       sigval = 11;
 695       break;                    /* stack exception */
 696     case 13:
 697       sigval = 11;
 698       break;                    /* general protection */
 699     case 14:
 700       sigval = 11;
 701       break;                    /* page fault */
 702     case 16:
 703       sigval = 7;
 704       break;                    /* coprocessor error */
 705     default:
 706       sigval = 7;               /* "software generated" */
 707     }
 708   return (sigval);
 709 }
 710
 711 /**********************************************/
 712 /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
 713 /* RETURN NUMBER OF CHARS PROCESSED           */
 714 /**********************************************/
 715 int
 716 hexToInt (char **ptr, int *intValue)
 717 {
 718   int numChars = 0;
 719   int hexValue;
 720
 721   *intValue = 0;
 722
 723   while (**ptr)
 724     {
 725       hexValue = hex (**ptr);
 726       if (hexValue >= 0)
 727         {
 728           *intValue = (*intValue << 4) | hexValue;
 729           numChars++;
 730         }
 731       else
 732         break;
 733
 734       (*ptr)++;
 735     }
 736
 737   return (numChars);
 738 }
 739
 740 /*
 741  * This function does all command procesing for interfacing to gdb.
 742  */
 743 void
 744 handle_exception (int exceptionVector)
 745 {
 746   int sigval, stepping;
 747   int addr, length;
 748   char *ptr;
 749   int newPC;
 750
 751   gdb_i386vector = exceptionVector;
 752
 753   if (remote_debug)
 754     {
 755       printf ("vector=%d, sr=0x%x, pc=0x%x\n",
 756               exceptionVector, registers[PS], registers[PC]);
 757     }
 758
 759   /* reply to host that an exception has occurred */
 760   sigval = computeSignal (exceptionVector);
 761
 762   ptr = remcomOutBuffer;
 763
 764   *ptr++ = 'T';                 /* notify gdb with signo, PC, FP and SP */
 765   *ptr++ = hexchars[sigval >> 4];
 766   *ptr++ = hexchars[sigval & 0xf];
 767
 768   *ptr++ = hexchars[ESP];
 769   *ptr++ = ':';
 770   ptr = mem2hex((char *)&registers[ESP], ptr, 4, 0);    /* SP */
 771   *ptr++ = ';';
 772
 773   *ptr++ = hexchars[EBP];
 774   *ptr++ = ':';
 775   ptr = mem2hex((char *)&registers[EBP], ptr, 4, 0);    /* FP */
 776   *ptr++ = ';';
 777
 778   *ptr++ = hexchars[PC];
 779   *ptr++ = ':';
 780   ptr = mem2hex((char *)&registers[PC], ptr, 4, 0);     /* PC */
 781   *ptr++ = ';';
 782
 783   *ptr = '\0'
 784
 785   putpacket (remcomOutBuffer);
 786
 787   stepping = 0;
 788
 789   while (1 == 1)
 790     {
 791       remcomOutBuffer[0] = 0;
 792       ptr = getpacket ();
 793
 794       switch (*ptr++)
 795         {
 796         case '?':
 797           remcomOutBuffer[0] = 'S';
 798           remcomOutBuffer[1] = hexchars[sigval >> 4];
 799           remcomOutBuffer[2] = hexchars[sigval % 16];
 800           remcomOutBuffer[3] = 0;
 801           break;
 802         case 'd':
 803           remote_debug = !(remote_debug);       /* toggle debug flag */
 804           break;
 805         case 'g':               /* return the value of the CPU registers */
 806           mem2hex ((char *) registers, remcomOutBuffer, NUMREGBYTES, 0);
 807           break;
 808         case 'G':               /* set the value of the CPU registers - return OK */
 809           hex2mem (ptr, (char *) registers, NUMREGBYTES, 0);
 810           strcpy (remcomOutBuffer, "OK");
 811           break;
 812         case 'P':               /* set the value of a single CPU register - return OK */
 813           {
 814             int regno;
 815
 816             if (hexToInt (&ptr, &regno) && *ptr++ == '=')
 817               if (regno >= 0 && regno < NUMREGS)
 818                 {
 819                   hex2mem (ptr, (char *) &registers[regno], 4, 0);
 820                   strcpy (remcomOutBuffer, "OK");
 821                   break;
 822                 }
 823
 824             strcpy (remcomOutBuffer, "E01");
 825             break;
 826           }
 827
 828           /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
 829         case 'm':
 830           /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
 831           if (hexToInt (&ptr, &addr))
 832             if (*(ptr++) == ',')
 833               if (hexToInt (&ptr, &length))
 834                 {
 835                   ptr = 0;
 836                   mem_err = 0;
 837                   mem2hex ((char *) addr, remcomOutBuffer, length, 1);
 838                   if (mem_err)
 839                     {
 840                       strcpy (remcomOutBuffer, "E03");
 841                       debug_error ("memory fault");
 842                     }
 843                 }
 844
 845           if (ptr)
 846             {
 847               strcpy (remcomOutBuffer, "E01");
 848             }
 849           break;
 850
 851           /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
 852         case 'M':
 853           /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
 854           if (hexToInt (&ptr, &addr))
 855             if (*(ptr++) == ',')
 856               if (hexToInt (&ptr, &length))
 857                 if (*(ptr++) == ':')
 858                   {
 859                     mem_err = 0;
 860                     hex2mem (ptr, (char *) addr, length, 1);
 861
 862                     if (mem_err)
 863                       {
 864                         strcpy (remcomOutBuffer, "E03");
 865                         debug_error ("memory fault");
 866                       }
 867                     else
 868                       {
 869                         strcpy (remcomOutBuffer, "OK");
 870                       }
 871
 872                     ptr = 0;
 873                   }
 874           if (ptr)
 875             {
 876               strcpy (remcomOutBuffer, "E02");
 877             }
 878           break;
 879
 880           /* cAA..AA    Continue at address AA..AA(optional) */
 881           /* sAA..AA   Step one instruction from AA..AA(optional) */
 882         case 's':
 883           stepping = 1;
 884         case 'c':
 885           /* try to read optional parameter, pc unchanged if no parm */
 886           if (hexToInt (&ptr, &addr))
 887             registers[PC] = addr;
 888
 889           newPC = registers[PC];
 890
 891           /* clear the trace bit */
 892           registers[PS] &= 0xfffffeff;
 893
 894           /* set the trace bit if we're stepping */
 895           if (stepping)
 896             registers[PS] |= 0x100;
 897
 898           _returnFromException ();      /* this is a jump */
 899           break;
 900
 901           /* kill the program */
 902         case 'k':               /* do nothing */
 903 #if 0
 904           /* Huh? This doesn't look like "nothing".
 905              m68k-stub.c and sparc-stub.c don't have it.  */
 906           BREAKPOINT ();
 907 #endif
 908           break;
 909         }                       /* switch */
 910
 911       /* reply to the request */
 912       putpacket (remcomOutBuffer);
 913     }
 914 }
 915
 916 /* this function is used to set up exception handlers for tracing and
 917    breakpoints */
 918 void
 919 set_debug_traps (void)
 920 {
 921   stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
 922
 923   exceptionHandler (0, _catchException0);
 924   exceptionHandler (1, _catchException1);
 925   exceptionHandler (3, _catchException3);
 926   exceptionHandler (4, _catchException4);
 927   exceptionHandler (5, _catchException5);
 928   exceptionHandler (6, _catchException6);
 929   exceptionHandler (7, _catchException7);
 930   exceptionHandler (8, _catchException8);
 931   exceptionHandler (9, _catchException9);
 932   exceptionHandler (10, _catchException10);
 933   exceptionHandler (11, _catchException11);
 934   exceptionHandler (12, _catchException12);
 935   exceptionHandler (13, _catchException13);
 936   exceptionHandler (14, _catchException14);
 937   exceptionHandler (16, _catchException16);
 938
 939   initialized = 1;
 940 }
 941
 942 /* This function will generate a breakpoint exception.  It is used at the
 943    beginning of a program to sync up with a debugger and can be used
 944    otherwise as a quick means to stop program execution and "break" into
 945    the debugger. */
 946
 947 void
 948 breakpoint (void)
 949 {
 950   if (initialized)
 951     BREAKPOINT ();
 952 }