gdb/i386-nlmstub.c

   1 /* i386-nlmstub.c -- NLM debugging stub for the i386.
   2
   3    This is originally based on an m68k software stub written by Glenn
   4    Engel at HP, but has changed quite a bit.  It was modified for the
   5    i386 by Jim Kingdon, Cygnus Support.  It was modified to run under
   6    NetWare by Ian Lance Taylor, Cygnus Support.
   7
   8    This code is intended to produce an NLM (a NetWare Loadable Module)
   9    to run under NetWare on an i386 platform.  To create the NLM,
  10    compile this code into an object file using the NLM SDK on any i386
  11    host, and use the nlmconv program (available in the GNU binutils)
  12    to transform the resulting object file into an NLM.  */
  13
  14 /****************************************************************************
  15
  16                 THIS SOFTWARE IS NOT COPYRIGHTED
  17
  18    HP offers the following for use in the public domain.  HP makes no
  19    warranty with regard to the software or it's performance and the
  20    user accepts the software "AS IS" with all faults.
  21
  22    HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
  23    TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  24    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  25
  26 ****************************************************************************/
  27
  28 /****************************************************************************
  29  *
  30  *    The following gdb commands are supported:
  31  *
  32  * command          function                               Return value
  33  *
  34  *    g             return the value of the CPU registers  hex data or ENN
  35  *    G             set the value of the CPU registers     OK or ENN
  36  *
  37  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
  38  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
  39  *
  40  *    c             Resume at current address              SNN   ( signal NN)
  41  *    cAA..AA       Continue at address AA..AA             SNN
  42  *
  43  *    s             Step one instruction                   SNN
  44  *    sAA..AA       Step one instruction from AA..AA       SNN
  45  *
  46  *    k             kill
  47  *
  48  *    ?             What was the last sigval ?             SNN   (signal NN)
  49  *
  50  * All commands and responses are sent with a packet which includes a
  51  * checksum.  A packet consists of
  52  *
  53  * $<packet info>#<checksum>.
  54  *
  55  * where
  56  * <packet info> :: <characters representing the command or response>
  57  * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
  58  *
  59  * When a packet is received, it is first acknowledged with either '+' or '-'.
  60  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
  61  *
  62  * Example:
  63  *
  64  * Host:                  Reply:
  65  * $m0,10#2a               +$00010203040506070809101112131415#42
  66  *
  67  ****************************************************************************/
  68
  69 #include <dfs.h>
  70 #include <stdio.h>
  71 #include <string.h>
  72 #include <stdlib.h>
  73 #include <ctype.h>
  74 #include <time.h>
  75 #include <aio.h>
  76 #include <conio.h>
  77 #include <advanced.h>
  78 #include <debugapi.h>
  79 #include <process.h>
  80 #include <errno.h>
  81
  82 /****************************************************/
  83 /* This information is from Novell.  It is not in any of the standard
  84    NetWare header files.  */
  85
  86 struct DBG_LoadDefinitionStructure
  87 {
  88         void *reserved1[4];
  89         LONG reserved5;
  90         LONG LDCodeImageOffset;
  91         LONG LDCodeImageLength;
  92         LONG LDDataImageOffset;
  93         LONG LDDataImageLength;
  94         LONG LDUninitializedDataLength;
  95         LONG LDCustomDataOffset;
  96         LONG LDCustomDataSize;
  97         LONG reserved6[2];
  98         LONG (*LDInitializationProcedure)(void);
  99 };
 100
 101 #define LO_NORMAL               0x0000
 102 #define LO_STARTUP              0x0001
 103 #define LO_PROTECT              0x0002
 104 #define LO_DEBUG                0x0004
 105 #define LO_AUTO_LOAD            0x0008
 106
 107 /* Loader returned error codes */
 108 #define LOAD_COULD_NOT_FIND_FILE                        1
 109 #define LOAD_ERROR_READING_FILE                         2
 110 #define LOAD_NOT_NLM_FILE_FORMAT                        3
 111 #define LOAD_WRONG_NLM_FILE_VERSION                     4
 112 #define LOAD_REENTRANT_INITIALIZE_FAILURE       5
 113 #define LOAD_CAN_NOT_LOAD_MULTIPLE_COPIES       6
 114 #define LOAD_ALREADY_IN_PROGRESS                        7
 115 #define LOAD_NOT_ENOUGH_MEMORY                          8
 116 #define LOAD_INITIALIZE_FAILURE                         9
 117 #define LOAD_INCONSISTENT_FILE_FORMAT           10
 118 #define LOAD_CAN_NOT_LOAD_AT_STARTUP            11
 119 #define LOAD_AUTO_LOAD_MODULES_NOT_LOADED       12
 120 #define LOAD_UNRESOLVED_EXTERNAL                        13
 121 #define LOAD_PUBLIC_ALREADY_DEFINED                     14
 122 /****************************************************/
 123
 124 /* The main thread ID.  */
 125 static int mainthread;
 126
 127 /* The LoadDefinitionStructure of the NLM being debugged.  */
 128 static struct DBG_LoadDefinitionStructure *handle;
 129
 130 /* Whether we have connected to gdb.  */
 131 static int talking;
 132
 133 /* The actual first instruction in the program.  */
 134 static unsigned char first_insn;
 135
 136 /* An error message for the main thread to print.  */
 137 static char *error_message;
 138
 139 /* The AIO port handle.  */
 140 static int AIOhandle;
 141
 142 /* BUFMAX defines the maximum number of characters in inbound/outbound
 143    buffers.  At least NUMREGBYTES*2 are needed for register packets */
 144 #define BUFMAX 400
 145
 146 /* remote_debug > 0 prints ill-formed commands in valid packets and
 147    checksum errors. */
 148 static int remote_debug = 1;
 149
 150 static const char hexchars[] = "0123456789abcdef";
 151
 152 /* Number of bytes of registers.  */
 153 #define NUMREGBYTES 64
 154 enum regnames {EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI,
 155                PC /* also known as eip */,
 156                PS /* also known as eflags */,
 157                CS, SS, DS, ES, FS, GS};
 158
 159 /* Register values.  */
 160 static int registers[NUMREGBYTES/4];
 161
 162 __main() {};
 163
 164 /* Read a character from the serial port.  This must busy wait, but
 165    that's OK because we will be the only thread running anyhow.  */
 166
 167 static int
 168 getDebugChar ()
 169 {
 170   int err;
 171   LONG got;
 172   unsigned char ret;
 173
 174   do
 175     {
 176       err = AIOReadData (AIOhandle, (char *) &ret, 1, &got);
 177       if (err != 0)
 178         {
 179           error_message = "AIOReadData failed";
 180           ResumeThread (mainthread);
 181           return -1;
 182         }
 183     }
 184   while (got == 0);
 185
 186   return ret;
 187 }
 188
 189 /* Write a character to the serial port.  Returns 0 on failure,
 190    non-zero on success.  */
 191
 192 static int
 193 putDebugChar (c)
 194      unsigned char c;
 195 {
 196   int err;
 197   LONG put;
 198
 199   put = 0;
 200   while (put < 1)
 201     {
 202       err = AIOWriteData (AIOhandle, (char *) &c, 1, &put);
 203       if (err != 0)
 204         ConsolePrintf ("AIOWriteData: err = %d, put = %d\r\n", err, put);
 205     }
 206   return 1;
 207 }
 208
 209 /* Get the registers out of the frame information.  */
 210
 211 static void
 212 frame_to_registers (frame, regs)
 213      T_TSS_StackFrame *frame;
 214      int *regs;
 215 {
 216   regs[EAX] = frame->ExceptionEAX;
 217   regs[ECX] = frame->ExceptionECX;
 218   regs[EDX] = frame->ExceptionEDX;
 219   regs[EBX] = frame->ExceptionEBX;
 220   regs[ESP] = frame->ExceptionESP;
 221   regs[EBP] = frame->ExceptionEBP;
 222   regs[ESI] = frame->ExceptionESI;
 223   regs[EDI] = frame->ExceptionEDI;
 224   regs[PC] = frame->ExceptionEIP;
 225   regs[PS] = frame->ExceptionSystemFlags;
 226   regs[CS] = frame->ExceptionCS[0];
 227   regs[SS] = frame->ExceptionSS[0];
 228   regs[DS] = frame->ExceptionDS[0];
 229   regs[ES] = frame->ExceptionES[0];
 230   regs[FS] = frame->ExceptionFS[0];
 231   regs[GS] = frame->ExceptionGS[0];
 232 }
 233
 234 /* Put the registers back into the frame information.  */
 235
 236 static void
 237 registers_to_frame (regs, frame)
 238      int *regs;
 239      T_TSS_StackFrame *frame;
 240 {
 241   frame->ExceptionEAX = regs[EAX];
 242   frame->ExceptionECX = regs[ECX];
 243   frame->ExceptionEDX = regs[EDX];
 244   frame->ExceptionEBX = regs[EBX];
 245   frame->ExceptionESP = regs[ESP];
 246   frame->ExceptionEBP = regs[EBP];
 247   frame->ExceptionESI = regs[ESI];
 248   frame->ExceptionEDI = regs[EDI];
 249   frame->ExceptionEIP = regs[PC];
 250   frame->ExceptionSystemFlags = regs[PS];
 251   frame->ExceptionCS[0] = regs[CS];
 252   frame->ExceptionSS[0] = regs[SS];
 253   frame->ExceptionDS[0] = regs[DS];
 254   frame->ExceptionES[0] = regs[ES];
 255   frame->ExceptionFS[0] = regs[FS];
 256   frame->ExceptionGS[0] = regs[GS];
 257 }
 258
 259 /* Turn a hex character into a number.  */
 260
 261 static int
 262 hex (ch)
 263      char ch;
 264 {
 265   if ((ch >= 'a') && (ch <= 'f'))
 266     return (ch-'a'+10);
 267   if ((ch >= '0') && (ch <= '9'))
 268     return (ch-'0');
 269   if ((ch >= 'A') && (ch <= 'F'))
 270     return (ch-'A'+10);
 271   return (-1);
 272 }
 273
 274 /* Scan for the sequence $<data>#<checksum>.  Returns 0 on failure,
 275    non-zero on success.  */
 276
 277 static int
 278 getpacket (buffer)
 279      char * buffer;
 280 {
 281   unsigned char checksum;
 282   unsigned char xmitcsum;
 283   int i;
 284   int count;
 285   int ch;
 286
 287   do
 288     {
 289       /* wait around for the start character, ignore all other characters */
 290       while ((ch = getDebugChar()) != '$')
 291         if (ch == -1)
 292           return 0;
 293       checksum = 0;
 294       xmitcsum = -1;
 295
 296       count = 0;
 297
 298       /* now, read until a # or end of buffer is found */
 299       while (count < BUFMAX)
 300         {
 301           ch = getDebugChar();
 302           if (ch == -1)
 303             return 0;
 304           if (ch == '#')
 305             break;
 306           checksum = checksum + ch;
 307           buffer[count] = ch;
 308           count = count + 1;
 309         }
 310       buffer[count] = 0;
 311
 312       if (ch == '#')
 313         {
 314           ch = getDebugChar ();
 315           if (ch == -1)
 316             return 0;
 317           xmitcsum = hex(ch) << 4;
 318           ch = getDebugChar ();
 319           if (ch == -1)
 320             return 0;
 321           xmitcsum += hex(ch);
 322           if ((remote_debug ) && (checksum != xmitcsum))
 323             {
 324               fprintf(stderr,"bad checksum.  My count = 0x%x, sent=0x%x. buf=%s\n",
 325                       checksum,xmitcsum,buffer);
 326             }
 327
 328           if (checksum != xmitcsum)
 329             {
 330               /* failed checksum */
 331               if (! putDebugChar('-'))
 332                 return 0;
 333             }
 334           else
 335             {
 336               /* successful transfer */
 337               if (! putDebugChar('+'))
 338                 return 0;
 339               /* if a sequence char is present, reply the sequence ID */
 340               if (buffer[2] == ':')
 341                 {
 342                   if (! putDebugChar (buffer[0])
 343                       || ! putDebugChar (buffer[1]))
 344                     return 0;
 345                   /* remove sequence chars from buffer */
 346                   count = strlen(buffer);
 347                   for (i=3; i <= count; i++)
 348                     buffer[i-3] = buffer[i];
 349                 }
 350             }
 351         }
 352     }
 353   while (checksum != xmitcsum);
 354
 355   if (remote_debug)
 356     ConsolePrintf ("Received packet \"%s\"\r\n", buffer);
 357
 358   return 1;
 359 }
 360
 361 /* Send the packet in buffer.  Returns 0 on failure, non-zero on
 362    success.  */
 363
 364 static int
 365 putpacket (buffer)
 366      char * buffer;
 367 {
 368   unsigned char checksum;
 369   int count;
 370   int ch;
 371
 372   if (remote_debug)
 373     ConsolePrintf ("Sending packet \"%s\"\r\n", buffer);
 374
 375   /*  $<packet info>#<checksum>. */
 376   do
 377     {
 378       if (! putDebugChar('$'))
 379         return 0;
 380       checksum = 0;
 381       count = 0;
 382
 383       while (ch=buffer[count])
 384         {
 385           if (! putDebugChar(ch))
 386             return 0;
 387           checksum += ch;
 388           count += 1;
 389         }
 390
 391       if (! putDebugChar('#')
 392           || ! putDebugChar(hexchars[checksum >> 4])
 393           || ! putDebugChar(hexchars[checksum % 16]))
 394         return 0;
 395
 396       ch = getDebugChar ();
 397       if (ch == -1)
 398         return 0;
 399     }
 400   while (ch != '+');
 401
 402   return 1;
 403 }
 404
 405 static char remcomInBuffer[BUFMAX];
 406 static char remcomOutBuffer[BUFMAX];
 407 static short error;
 408
 409 static void
 410 debug_error (format, parm)
 411      char *format;
 412      char *parm;
 413 {
 414   if (remote_debug)
 415     {
 416       fprintf (stderr, format, parm);
 417       fprintf (stderr, "\n");
 418     }
 419 }
 420
 421 /* This is set if we could get a memory access fault.  */
 422 static int mem_may_fault;
 423
 424 /* Indicate to caller of mem2hex or hex2mem that there has been an
 425    error.  */
 426 static volatile int mem_err = 0;
 427
 428 /* These are separate functions so that they are so short and sweet
 429    that the compiler won't save any registers (if there is a fault
 430    to mem_fault, they won't get restored, so there better not be any
 431    saved).  */
 432
 433 static int
 434 get_char (addr)
 435      char *addr;
 436 {
 437   return *addr;
 438 }
 439
 440 static void
 441 set_char (addr, val)
 442      char *addr;
 443      int val;
 444 {
 445   *addr = val;
 446 }
 447
 448 /* This bit of assembly language just returns from a function.  If a
 449    memory error occurs within get_char or set_char, the debugger
 450    handler points EIP at these instructions to get out.  */
 451
 452 extern void just_return ();
 453 asm (".globl just_return");
 454 asm (".globl _just_return");
 455 asm ("just_return:");
 456 asm ("_just_return:");
 457 asm ("leave");
 458 asm ("ret");
 459
 460 /* convert the memory pointed to by mem into hex, placing result in buf */
 461 /* return a pointer to the last char put in buf (null) */
 462 /* If MAY_FAULT is non-zero, then we should set mem_err in response to
 463    a fault; if zero treat a fault like any other fault in the stub.  */
 464
 465 static char *
 466 mem2hex (mem, buf, count, may_fault)
 467      char *mem;
 468      char *buf;
 469      int count;
 470      int may_fault;
 471 {
 472   int i;
 473   unsigned char ch;
 474
 475   mem_may_fault = may_fault;
 476   for (i = 0; i < count; i++)
 477     {
 478       ch = get_char (mem++);
 479       if (may_fault && mem_err)
 480         return (buf);
 481       *buf++ = hexchars[ch >> 4];
 482       *buf++ = hexchars[ch % 16];
 483     }
 484   *buf = 0;
 485   mem_may_fault = 0;
 486   return(buf);
 487 }
 488
 489 /* convert the hex array pointed to by buf into binary to be placed in mem */
 490 /* return a pointer to the character AFTER the last byte written */
 491
 492 static char *
 493 hex2mem (buf, mem, count, may_fault)
 494      char *buf;
 495      char *mem;
 496      int count;
 497      int may_fault;
 498 {
 499   int i;
 500   unsigned char ch;
 501
 502   mem_may_fault = may_fault;
 503   for (i=0;i<count;i++)
 504     {
 505       ch = hex(*buf++) << 4;
 506       ch = ch + hex(*buf++);
 507       set_char (mem++, ch);
 508       if (may_fault && mem_err)
 509         return (mem);
 510     }
 511   mem_may_fault = 0;
 512   return(mem);
 513 }
 514
 515 /* This function takes the 386 exception vector and attempts to
 516    translate this number into a unix compatible signal value.  */
 517
 518 static int
 519 computeSignal (exceptionVector)
 520      int exceptionVector;
 521 {
 522   int sigval;
 523   switch (exceptionVector)
 524     {
 525     case 0 : sigval = 8; break; /* divide by zero */
 526     case 1 : sigval = 5; break; /* debug exception */
 527     case 3 : sigval = 5; break; /* breakpoint */
 528     case 4 : sigval = 16; break; /* into instruction (overflow) */
 529     case 5 : sigval = 16; break; /* bound instruction */
 530     case 6 : sigval = 4; break; /* Invalid opcode */
 531     case 7 : sigval = 8; break; /* coprocessor not available */
 532     case 8 : sigval = 7; break; /* double fault */
 533     case 9 : sigval = 11; break; /* coprocessor segment overrun */
 534     case 10 : sigval = 11; break; /* Invalid TSS */
 535     case 11 : sigval = 11; break; /* Segment not present */
 536     case 12 : sigval = 11; break; /* stack exception */
 537     case 13 : sigval = 11; break; /* general protection */
 538     case 14 : sigval = 11; break; /* page fault */
 539     case 16 : sigval = 7; break; /* coprocessor error */
 540     default:
 541       sigval = 7;               /* "software generated"*/
 542     }
 543   return (sigval);
 544 }
 545
 546 /**********************************************/
 547 /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
 548 /* RETURN NUMBER OF CHARS PROCESSED           */
 549 /**********************************************/
 550 static int
 551 hexToInt(ptr, intValue)
 552      char **ptr;
 553      int *intValue;
 554 {
 555   int numChars = 0;
 556   int hexValue;
 557
 558   *intValue = 0;
 559
 560   while (**ptr)
 561     {
 562       hexValue = hex(**ptr);
 563       if (hexValue >=0)
 564         {
 565           *intValue = (*intValue <<4) | hexValue;
 566           numChars ++;
 567         }
 568       else
 569         break;
 570
 571       (*ptr)++;
 572     }
 573
 574   return (numChars);
 575 }
 576
 577 /* This function does all command processing for interfacing to gdb.
 578    It is called whenever an exception occurs in the module being
 579    debugged.  */
 580
 581 static LONG
 582 handle_exception (T_StackFrame *old_frame)
 583 {
 584   T_TSS_StackFrame *frame = (T_TSS_StackFrame *) old_frame;
 585   int sigval;
 586   int addr, length;
 587   char * ptr;
 588   int newPC;
 589
 590   /* Apparently the bell can sometimes be ringing at this point, and
 591      should be stopped.  */
 592   StopBell ();
 593
 594   if (remote_debug)
 595     {
 596       ConsolePrintf ("vector=%d: %s, sr=%08x, pc=%08x, thread=%08x\r\n",
 597                      frame->ExceptionNumber,
 598                      frame->ExceptionDescription,
 599                      frame->ExceptionSystemFlags,
 600                      frame->ExceptionEIP,
 601                      GetThreadID ());
 602     }
 603
 604   /* If the NLM just started, we record the module load information
 605      and the thread ID, and set a breakpoint at the first instruction
 606      in the program.  */
 607   if (frame->ExceptionNumber == START_NLM_EVENT
 608       && handle == NULL)
 609     {
 610       handle = ((struct DBG_LoadDefinitionStructure *)
 611                 frame->ExceptionErrorCode);
 612       first_insn = *(char *) handle->LDInitializationProcedure;
 613       *(unsigned char *) handle->LDInitializationProcedure = 0xcc;
 614       ConsolePrintf ("NLM offsets/lengths:  Code: 0x%x/0x%x, Data: 0x%x/0x%x, BSS: /0x%x\r\n",
 615                      handle->LDCodeImageOffset, handle->LDCodeImageLength,
 616                      handle->LDDataImageOffset, handle->LDDataImageLength,
 617                      handle->LDUninitializedDataLength);
 618
 619       return RETURN_TO_PROGRAM;
 620     }
 621
 622   /* After we've reached the initial breakpoint, reset it.  */
 623   if (frame->ExceptionEIP == (LONG) handle->LDInitializationProcedure + 1
 624       && *(unsigned char *) handle->LDInitializationProcedure == 0xcc)
 625     {
 626       *(char *) handle->LDInitializationProcedure = first_insn;
 627       frame->ExceptionEIP = (LONG) handle->LDInitializationProcedure;
 628     }
 629
 630   /* Pass some events on to the next debugger, in case it will handle
 631      them.  */
 632   if (frame->ExceptionNumber == ENTER_DEBUGGER_EVENT
 633       || frame->ExceptionNumber == KEYBOARD_BREAK_EVENT)
 634     return RETURN_TO_NEXT_DEBUGGER;
 635
 636   /* At the moment, we don't care about most of the unusual NetWare
 637      exceptions.  */
 638   if (frame->ExceptionNumber != TERMINATE_NLM_EVENT
 639       && frame->ExceptionNumber > 31)
 640     return RETURN_TO_PROGRAM;
 641
 642   /* If we get a GP fault, and mem_may_fault is set, and the
 643      instruction pointer is near set_char or get_char, then we caused
 644      the fault ourselves accessing an illegal memory location.  */
 645   if (mem_may_fault
 646       && (frame->ExceptionNumber == 11
 647           || frame->ExceptionNumber == 13
 648           || frame->ExceptionNumber == 14)
 649       && ((frame->ExceptionEIP >= (long) &set_char
 650            && frame->ExceptionEIP < (long) &set_char + 50)
 651           || (frame->ExceptionEIP >= (long) &get_char
 652               && frame->ExceptionEIP < (long) &get_char + 50)))
 653     {
 654       mem_err = 1;
 655       /* Point the instruction pointer at an assembly language stub
 656          which just returns from the function.  */
 657       frame->ExceptionEIP = (long) &just_return;
 658       /* Keep going.  This will act as though it returned from
 659          set_char or get_char.  The calling routine will check
 660          mem_err, and do the right thing.  */
 661       return RETURN_TO_PROGRAM;
 662     }
 663
 664   /* FIXME: How do we know that this exception has anything to do with
 665      the program we are debugging?  We can check whether the PC is in
 666      the range of the module we are debugging, but that doesn't help
 667      much since an error could occur in a library routine.  */
 668
 669   frame_to_registers (frame, registers);
 670
 671   /* reply to host that an exception has occurred */
 672   if (frame->ExceptionNumber == TERMINATE_NLM_EVENT)
 673     {
 674       /* There is no way to get the exit status.  */
 675       remcomOutBuffer[0] = 'W';
 676       remcomOutBuffer[1] = hexchars[0];
 677       remcomOutBuffer[2] = hexchars[0];
 678       remcomOutBuffer[3] = 0;
 679     }
 680   else
 681     {
 682       sigval = computeSignal (frame->ExceptionNumber);
 683       remcomOutBuffer[0] = 'N';
 684       remcomOutBuffer[1] =  hexchars[sigval >> 4];
 685       remcomOutBuffer[2] =  hexchars[sigval % 16];
 686       sprintf (remcomOutBuffer + 3, "%x;%x;%x",
 687                handle->LDCodeImageOffset,
 688                handle->LDDataImageOffset,
 689                handle->LDDataImageOffset + handle->LDDataImageLength);
 690     }
 691
 692   if (! putpacket(remcomOutBuffer))
 693     return RETURN_TO_NEXT_DEBUGGER;
 694
 695   if (frame->ExceptionNumber == TERMINATE_NLM_EVENT)
 696     {
 697       ResumeThread (mainthread);
 698       return RETURN_TO_PROGRAM;
 699     }
 700
 701   while (1)
 702     {
 703       error = 0;
 704       remcomOutBuffer[0] = 0;
 705       if (! getpacket (remcomInBuffer))
 706         return RETURN_TO_NEXT_DEBUGGER;
 707       talking = 1;
 708       switch (remcomInBuffer[0])
 709         {
 710         case '?':
 711           sigval = computeSignal (frame->ExceptionNumber);
 712           remcomOutBuffer[0] = 'N';
 713           remcomOutBuffer[1] =  hexchars[sigval >> 4];
 714           remcomOutBuffer[2] =  hexchars[sigval % 16];
 715           sprintf (remcomOutBuffer + 3, "%x;%x;%x",
 716                    handle->LDCodeImageOffset,
 717                    handle->LDDataImageOffset,
 718                    handle->LDDataImageOffset + handle->LDDataImageLength);
 719           break;
 720         case 'd':
 721           remote_debug = !(remote_debug); /* toggle debug flag */
 722           break;
 723         case 'g':
 724           /* return the value of the CPU registers */
 725           mem2hex((char*) registers, remcomOutBuffer, NUMREGBYTES, 0);
 726           break;
 727         case 'G':
 728           /* set the value of the CPU registers - return OK */
 729           hex2mem(&remcomInBuffer[1], (char*) registers, NUMREGBYTES, 0);
 730           strcpy(remcomOutBuffer,"OK");
 731           break;
 732
 733         case 'm':
 734           /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
 735           /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
 736           ptr = &remcomInBuffer[1];
 737           if (hexToInt(&ptr,&addr))
 738             if (*(ptr++) == ',')
 739               if (hexToInt(&ptr,&length))
 740                 {
 741                   ptr = 0;
 742                   mem_err = 0;
 743                   mem2hex((char*) addr, remcomOutBuffer, length, 1);
 744                   if (mem_err)
 745                     {
 746                       strcpy (remcomOutBuffer, "E03");
 747                       debug_error ("memory fault");
 748                     }
 749                 }
 750
 751           if (ptr)
 752             {
 753               strcpy(remcomOutBuffer,"E01");
 754               debug_error("malformed read memory command: %s",remcomInBuffer);
 755             }
 756           break;
 757
 758         case 'M':
 759           /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
 760           /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
 761           ptr = &remcomInBuffer[1];
 762           if (hexToInt(&ptr,&addr))
 763             if (*(ptr++) == ',')
 764               if (hexToInt(&ptr,&length))
 765                 if (*(ptr++) == ':')
 766                   {
 767                     mem_err = 0;
 768                     hex2mem(ptr, (char*) addr, length, 1);
 769
 770                     if (mem_err)
 771                       {
 772                         strcpy (remcomOutBuffer, "E03");
 773                         debug_error ("memory fault");
 774                       }
 775                     else
 776                       {
 777                         strcpy(remcomOutBuffer,"OK");
 778                       }
 779
 780                     ptr = 0;
 781                   }
 782           if (ptr)
 783             {
 784               strcpy(remcomOutBuffer,"E02");
 785               debug_error("malformed write memory command: %s",remcomInBuffer);
 786             }
 787           break;
 788
 789         case 'c':
 790         case 's':
 791           /* cAA..AA    Continue at address AA..AA(optional) */
 792           /* sAA..AA   Step one instruction from AA..AA(optional) */
 793           /* try to read optional parameter, pc unchanged if no parm */
 794           ptr = &remcomInBuffer[1];
 795           if (hexToInt(&ptr,&addr))
 796             registers[ PC ] = addr;
 797
 798           newPC = registers[ PC];
 799
 800           /* clear the trace bit */
 801           registers[ PS ] &= 0xfffffeff;
 802
 803           /* set the trace bit if we're stepping */
 804           if (remcomInBuffer[0] == 's') registers[ PS ] |= 0x100;
 805
 806           registers_to_frame (registers, frame);
 807           return RETURN_TO_PROGRAM;
 808
 809         case 'k':
 810           /* kill the program */
 811           KillMe (handle);
 812           ResumeThread (mainthread);
 813           return RETURN_TO_PROGRAM;
 814         }
 815
 816       /* reply to the request */
 817       if (! putpacket(remcomOutBuffer))
 818         return RETURN_TO_NEXT_DEBUGGER;
 819     }
 820 }
 821
 822 char *baudRates[] = { "50", "75", "110", "134.5", "150", "300", "600", "1200",
 823                         "1800", "2000", "2400", "3600", "4800", "7200", "9600",
 824                         "19200", "38400", "57600", "115200" };
 825
 826 char dataBits[] = "5678";
 827
 828 char *stopBits[] = { "1", "1.5", "2" };
 829
 830 char parity[] = "NOEMS";
 831
 832 /* Start up.  The main thread opens the named serial I/O port, loads
 833    the named NLM module and then goes to sleep.  The serial I/O port
 834    is named as a board number and a port number.  It would be more DOS
 835    like to provide a menu of available serial ports, but I don't want
 836    to have to figure out how to do that.  */
 837
 838 int
 839 main (argc, argv)
 840      int argc;
 841      char **argv;
 842 {
 843   int hardware, board, port;
 844   LONG err;
 845   struct debuggerStructure s;
 846   char *cmdlin;
 847   int i;
 848
 849 /* Use the -B option to invoke the NID if you want to debug the stub. */
 850
 851   if (argc > 1 && strcmp(argv[1], "-B") == 0)
 852     {
 853       Breakpoint(argc);
 854       ++argv, --argc;
 855     }
 856
 857   if (argc < 4)
 858     {
 859       fprintf (stderr,
 860                "Usage: load gdbserve board port program [arguments]\n");
 861       exit (1);
 862     }
 863
 864   hardware = -1;
 865   board = strtol (argv[1], (char **) NULL, 0);
 866   port = strtol (argv[2], (char **) NULL, 0);
 867
 868   err = AIOAcquirePort (&hardware, &board, &port, &AIOhandle);
 869   if (err != AIO_SUCCESS)
 870     {
 871       switch (err)
 872         {
 873         case AIO_PORT_NOT_AVAILABLE:
 874           fprintf (stderr, "Port not available\n");
 875           break;
 876
 877         case AIO_BOARD_NUMBER_INVALID:
 878         case AIO_PORT_NUMBER_INVALID:
 879           fprintf (stderr, "No such port\n");
 880           break;
 881
 882         default:
 883           fprintf (stderr, "Could not open port: %d\n", err);
 884           break;
 885         }
 886
 887       exit (1);
 888     }
 889
 890   err = AIOConfigurePort (AIOhandle, AIO_BAUD_9600, AIO_DATA_BITS_8,
 891                           AIO_STOP_BITS_1, AIO_PARITY_NONE,
 892                           AIO_HARDWARE_FLOW_CONTROL_OFF);
 893
 894   if (err == AIO_QUALIFIED_SUCCESS)
 895     {
 896       AIOPORTCONFIG portConfig;
 897       AIODVRCONFIG dvrConfig;
 898
 899       fprintf (stderr, "Port configuration changed!\n");
 900       AIOGetPortConfiguration (AIOhandle, &portConfig, &dvrConfig);
 901       fprintf (stderr,
 902                "  Bit Rate: %s, Data Bits: %c, Stop Bits: %s, Parity: %c,\
 903  Flow:%s\n",
 904                baudRates[portConfig.bitRate],
 905                dataBits[portConfig.dataBits],
 906                stopBits[portConfig.stopBits],
 907                parity[portConfig.parityMode],
 908                portConfig.flowCtrlMode ? "ON" : "OFF");
 909     }
 910   else if (err != AIO_SUCCESS)
 911     {
 912       fprintf (stderr, "Could not configure port: %d\n", err);
 913       AIOReleasePort (AIOhandle);
 914       exit (1);
 915     }
 916
 917   if (AIOSetExternalControl(AIOhandle, AIO_EXTERNAL_CONTROL,
 918                             (AIO_EXTCTRL_DTR | AIO_EXTCTRL_RTS))
 919       != AIO_SUCCESS)
 920     {
 921       LONG extStatus, chgdExtStatus;
 922
 923       fprintf (stderr, "Could not set desired port controls!\n");
 924       AIOGetExternalStatus (AIOhandle, &extStatus, &chgdExtStatus);
 925       fprintf (stderr, "Port controls now: %d, %d\n", extStatus,
 926                chgdExtStatus);
 927     }
 928
 929   /* Register ourselves as an alternate debugger.  */
 930   memset (&s, 0, sizeof s);
 931   s.DDSResourceTag = ((struct ResourceTagStructure *)
 932                       AllocateResourceTag (GetNLMHandle (),
 933                                            "gdbserver",
 934                                            DebuggerSignature));
 935   if (s.DDSResourceTag == 0)
 936     {
 937       fprintf (stderr, "AllocateResourceTag failed\n");
 938       AIOReleasePort (AIOhandle);
 939       exit (1);
 940     }
 941   s.DDSdebuggerEntry = handle_exception;
 942   s.DDSFlags = TSS_FRAME_BIT;
 943
 944   err = RegisterDebuggerRTag (&s, AT_FIRST);
 945   if (err != 0)
 946     {
 947       fprintf (stderr, "RegisterDebuggerRTag failed\n");
 948       AIOReleasePort (AIOhandle);
 949       exit (1);
 950     }
 951
 952   /* Get the command line we were invoked with, and advance it past
 953      our name and the board and port arguments.  */
 954   cmdlin = getcmd ((char *) NULL);
 955   for (i = 0; i < 2; i++)
 956     {
 957       while (! isspace (*cmdlin))
 958         ++cmdlin;
 959       while (isspace (*cmdlin))
 960         ++cmdlin;
 961     }
 962
 963   /* In case GDB is started before us, ack any packets (presumably
 964      "$?#xx") sitting there.  */
 965   if (! putDebugChar ('+'))
 966     {
 967       fprintf (stderr, "putDebugChar failed\n");
 968       UnRegisterDebugger (&s);
 969       AIOReleasePort (AIOhandle);
 970       exit (1);
 971     }
 972
 973   mainthread = GetThreadID ();
 974   handle = NULL;
 975   talking = 0;
 976
 977   if (remote_debug > 0)
 978     ConsolePrintf ("About to call LoadModule with \"%s\" %08x\r\n",
 979                    cmdlin, __GetScreenID (GetCurrentScreen()));
 980
 981   /* Start up the module to be debugged.  */
 982   err = LoadModule ((struct ScreenStruct *) __GetScreenID (GetCurrentScreen()),
 983                     cmdlin, LO_DEBUG);
 984   if (err != 0)
 985     {
 986       fprintf (stderr, "LoadModule failed: %d\n", err);
 987       UnRegisterDebugger (&s);
 988       AIOReleasePort (AIOhandle);
 989       exit (1);
 990     }
 991
 992   /* Wait for the debugger to wake us up.  */
 993   if (remote_debug > 0)
 994     ConsolePrintf ("Suspending main thread (%08x)\r\n", mainthread);
 995   SuspendThread (mainthread);
 996   if (remote_debug > 0)
 997     ConsolePrintf ("Resuming main thread (%08x)\r\n", mainthread);
 998
 999   /* If we are woken up, print an optional error message, deregister
1000      ourselves and exit.  */
1001   if (error_message != NULL)
1002     fprintf (stderr, "%s\n", error_message);
1003   UnRegisterDebugger (&s);
1004   AIOReleasePort (AIOhandle);
1005   exit (0);
1006 }