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 /* An error message for the main thread to print.  */
 128 static char *error_message;
 129
 130 /* The AIO port handle.  */
 131 static int AIOhandle;
 132
 133 /* BUFMAX defines the maximum number of characters in inbound/outbound
 134    buffers.  At least NUMREGBYTES*2 are needed for register packets */
 135 #define BUFMAX (REGISTER_BYTES * 2 + 16)
 136
 137 /* remote_debug > 0 prints ill-formed commands in valid packets and
 138    checksum errors. */
 139 static int remote_debug = 1;
 140
 141 static const char hexchars[] = "0123456789abcdef";
 142
 143 /* Register values.  All of these values *MUST* agree with tm.h */
 144 #define SP_REGNUM 4             /* Contains address of top of stack */
 145 #define PC_REGNUM 8             /* Contains program counter */
 146 #define FP_REGNUM 5             /* Virtual frame pointer */
 147 #define NUM_REGS 16             /* Number of machine registers */
 148 #define REGISTER_BYTES (NUM_REGS * 4) /* Total size of registers array */
 149
 150 #define ExceptionPC ExceptionEIP
 151 #define DECR_PC_AFTER_BREAK 1   /* int 3 leaves PC pointing after insn */
 152 #define BREAKPOINT {0xcc}
 153 #define StackFrame T_TSS_StackFrame
 154
 155 unsigned char breakpoint_insn[] = BREAKPOINT;
 156 #define BREAKPOINT_SIZE (sizeof breakpoint_insn)
 157
 158 static void flush_i_cache() {}
 159
 160 static char *mem2hex (void *mem, char *buf, int count, int may_fault);
 161 static char *hex2mem (char *buf, void *mem, int count, int may_fault);
 162 static void set_step_traps (struct StackFrame *);
 163 static void clear_step_traps (struct StackFrame *);
 164
 165 #if 0
 166 __main() {};
 167 #endif
 168
 169 /* Read a character from the serial port.  This must busy wait, but
 170    that's OK because we will be the only thread running anyhow.  */
 171
 172 static int
 173 getDebugChar ()
 174 {
 175   int err;
 176   LONG got;
 177   unsigned char ret;
 178
 179   do
 180     {
 181       err = AIOReadData (AIOhandle, (char *) &ret, 1, &got);
 182       if (err != 0)
 183         {
 184           error_message = "AIOReadData failed";
 185           ResumeThread (mainthread);
 186           return -1;
 187         }
 188     }
 189   while (got == 0);
 190
 191   return ret;
 192 }
 193
 194 /* Write a character to the serial port.  Returns 0 on failure,
 195    non-zero on success.  */
 196
 197 static int
 198 putDebugChar (c)
 199      unsigned char c;
 200 {
 201   int err;
 202   LONG put;
 203
 204   put = 0;
 205   while (put < 1)
 206     {
 207       err = AIOWriteData (AIOhandle, (char *) &c, 1, &put);
 208       if (err != 0)
 209         ConsolePrintf ("AIOWriteData: err = %d, put = %d\r\n", err, put);
 210     }
 211   return 1;
 212 }
 213
 214 /* Get the registers out of the frame information.  */
 215
 216 static void
 217 frame_to_registers (frame, regs)
 218      struct StackFrame *frame;
 219      char *regs;
 220 {
 221   /* Copy EAX -> EDI */
 222   mem2hex (&frame->ExceptionEAX, &regs[0 * 4 * 2], 4 * 8, 0);
 223
 224   /* Copy EIP & PS */
 225   mem2hex (&frame->ExceptionPC, &regs[8 * 4 * 2], 4 * 2, 0);
 226
 227   /* Copy CS, SS, DS */
 228   mem2hex (&frame->ExceptionCS, &regs[10 * 4 * 2], 4 * 3, 0);
 229
 230   /* Copy ES */
 231   mem2hex (&frame->ExceptionES, &regs[13 * 4 * 2], 4 * 1, 0);
 232
 233   /* Copy FS & GS */
 234   mem2hex (&frame->ExceptionFS, &regs[14 * 4 * 2], 4 * 2, 0);
 235 }
 236
 237 /* Put the registers back into the frame information.  */
 238
 239 static void
 240 registers_to_frame (regs, frame)
 241      char *regs;
 242      struct StackFrame *frame;
 243 {
 244   /* Copy EAX -> EDI */
 245   hex2mem (&regs[0 * 4 * 2], &frame->ExceptionEAX, 4 * 8, 0);
 246
 247   /* Copy EIP & PS */
 248   hex2mem (&regs[8 * 4 * 2], &frame->ExceptionPC, 4 * 2, 0);
 249
 250   /* Copy CS, SS, DS */
 251   hex2mem (&regs[10 * 4 * 2], &frame->ExceptionCS, 4 * 3, 0);
 252
 253   /* Copy ES */
 254   hex2mem (&regs[13 * 4 * 2], &frame->ExceptionES, 4 * 1, 0);
 255
 256   /* Copy FS & GS */
 257   hex2mem (&regs[14 * 4 * 2], &frame->ExceptionFS, 4 * 2, 0);
 258 }
 259
 260 /* Turn a hex character into a number.  */
 261
 262 static int
 263 hex (ch)
 264      char ch;
 265 {
 266   if ((ch >= 'a') && (ch <= 'f'))
 267     return (ch-'a'+10);
 268   if ((ch >= '0') && (ch <= '9'))
 269     return (ch-'0');
 270   if ((ch >= 'A') && (ch <= 'F'))
 271     return (ch-'A'+10);
 272   return (-1);
 273 }
 274
 275 /* Scan for the sequence $<data>#<checksum>.  Returns 0 on failure,
 276    non-zero on success.  */
 277
 278 static int
 279 getpacket (buffer)
 280      char * buffer;
 281 {
 282   unsigned char checksum;
 283   unsigned char xmitcsum;
 284   int i;
 285   int count;
 286   int ch;
 287
 288   do
 289     {
 290       /* wait around for the start character, ignore all other characters */
 291       while ((ch = getDebugChar()) != '$')
 292         if (ch == -1)
 293           return 0;
 294       checksum = 0;
 295       xmitcsum = -1;
 296
 297       count = 0;
 298
 299       /* now, read until a # or end of buffer is found */
 300       while (count < BUFMAX)
 301         {
 302           ch = getDebugChar();
 303           if (ch == -1)
 304             return 0;
 305           if (ch == '#')
 306             break;
 307           checksum = checksum + ch;
 308           buffer[count] = ch;
 309           count = count + 1;
 310         }
 311       buffer[count] = 0;
 312
 313       if (ch == '#')
 314         {
 315           ch = getDebugChar ();
 316           if (ch == -1)
 317             return 0;
 318           xmitcsum = hex(ch) << 4;
 319           ch = getDebugChar ();
 320           if (ch == -1)
 321             return 0;
 322           xmitcsum += hex(ch);
 323
 324           if (checksum != xmitcsum)
 325             {
 326               if (remote_debug)
 327                 ConsolePrintf ("bad checksum.  My count = 0x%x, sent=0x%x. buf=%s\n",
 328                                checksum,xmitcsum,buffer);
 329               /* failed checksum */
 330               if (! putDebugChar('-'))
 331                 return 0;
 332               return 1;
 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       ConsolePrintf (format, parm);
 417       ConsolePrintf ("\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      void *mem;
 468      char *buf;
 469      int count;
 470      int may_fault;
 471 {
 472   int i;
 473   unsigned char ch;
 474   char *ptr = mem;
 475
 476   mem_may_fault = may_fault;
 477   for (i = 0; i < count; i++)
 478     {
 479       ch = get_char (ptr++);
 480       if (may_fault && mem_err)
 481         return (buf);
 482       *buf++ = hexchars[ch >> 4];
 483       *buf++ = hexchars[ch % 16];
 484     }
 485   *buf = 0;
 486   mem_may_fault = 0;
 487   return(buf);
 488 }
 489
 490 /* convert the hex array pointed to by buf into binary to be placed in mem */
 491 /* return a pointer to the character AFTER the last byte written */
 492
 493 static char *
 494 hex2mem (buf, mem, count, may_fault)
 495      char *buf;
 496      void *mem;
 497      int count;
 498      int may_fault;
 499 {
 500   int i;
 501   unsigned char ch;
 502   char *ptr = mem;
 503
 504   mem_may_fault = may_fault;
 505   for (i=0;i<count;i++)
 506     {
 507       ch = hex(*buf++) << 4;
 508       ch = ch + hex(*buf++);
 509       set_char (ptr++, ch);
 510       if (may_fault && mem_err)
 511         return (ptr);
 512     }
 513   mem_may_fault = 0;
 514   return(mem);
 515 }
 516
 517 /* This function takes the 386 exception vector and attempts to
 518    translate this number into a unix compatible signal value.  */
 519
 520 static int
 521 computeSignal (exceptionVector)
 522      int exceptionVector;
 523 {
 524   int sigval;
 525   switch (exceptionVector)
 526     {
 527     case 0 : sigval = 8; break; /* divide by zero */
 528     case 1 : sigval = 5; break; /* debug exception */
 529     case 3 : sigval = 5; break; /* breakpoint */
 530     case 4 : sigval = 16; break; /* into instruction (overflow) */
 531     case 5 : sigval = 16; break; /* bound instruction */
 532     case 6 : sigval = 4; break; /* Invalid opcode */
 533     case 7 : sigval = 8; break; /* coprocessor not available */
 534     case 8 : sigval = 7; break; /* double fault */
 535     case 9 : sigval = 11; break; /* coprocessor segment overrun */
 536     case 10 : sigval = 11; break; /* Invalid TSS */
 537     case 11 : sigval = 11; break; /* Segment not present */
 538     case 12 : sigval = 11; break; /* stack exception */
 539     case 13 : sigval = 11; break; /* general protection */
 540     case 14 : sigval = 11; break; /* page fault */
 541     case 16 : sigval = 7; break; /* coprocessor error */
 542     default:
 543       sigval = 7;               /* "software generated"*/
 544     }
 545   return (sigval);
 546 }
 547
 548 /**********************************************/
 549 /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
 550 /* RETURN NUMBER OF CHARS PROCESSED           */
 551 /**********************************************/
 552 static int
 553 hexToInt(ptr, intValue)
 554      char **ptr;
 555      int *intValue;
 556 {
 557   int numChars = 0;
 558   int hexValue;
 559
 560   *intValue = 0;
 561
 562   while (**ptr)
 563     {
 564       hexValue = hex(**ptr);
 565       if (hexValue >=0)
 566         {
 567           *intValue = (*intValue <<4) | hexValue;
 568           numChars ++;
 569         }
 570       else
 571         break;
 572
 573       (*ptr)++;
 574     }
 575
 576   return (numChars);
 577 }
 578
 579 static void
 580 set_step_traps (frame)
 581      struct StackFrame *frame;
 582 {
 583   frame->ExceptionSystemFlags |= 0x100;
 584 }
 585
 586 static void
 587 clear_step_traps (frame)
 588      struct StackFrame *frame;
 589 {
 590   frame->ExceptionSystemFlags &= ~0x100;
 591 }
 592
 593 static void
 594 do_status (ptr, frame)
 595      char *ptr;
 596      struct StackFrame *frame;
 597 {
 598   int sigval;
 599
 600   sigval = computeSignal (frame->ExceptionNumber);
 601
 602   sprintf (ptr, "T%02x", sigval);
 603   ptr += 3;
 604
 605   sprintf (ptr, "%02x:", PC_REGNUM);
 606   ptr = mem2hex (&frame->ExceptionPC, ptr + 3, 4, 0);
 607   *ptr++ = ';';
 608
 609   sprintf (ptr, "%02x:", SP_REGNUM);
 610   ptr = mem2hex (&frame->ExceptionESP, ptr + 3, 4, 0);
 611   *ptr++ = ';';
 612
 613   sprintf (ptr, "%02x:", FP_REGNUM);
 614   ptr = mem2hex (&frame->ExceptionEBP, ptr + 3, 4, 0);
 615   *ptr++ = ';';
 616
 617   *ptr = '\000';
 618 }
 619
 620 /* This function does all command processing for interfacing to gdb.
 621    It is called whenever an exception occurs in the module being
 622    debugged.  */
 623
 624 static LONG
 625 handle_exception (frame)
 626      struct StackFrame *frame;
 627 {
 628   int addr, length;
 629   char *ptr;
 630   static int killed = 0;
 631   static struct DBG_LoadDefinitionStructure *ldinfo = 0;
 632   static unsigned char first_insn[BREAKPOINT_SIZE]; /* The first instruction in the program.  */
 633
 634   /* Apparently the bell can sometimes be ringing at this point, and
 635      should be stopped.  */
 636   StopBell ();
 637
 638   if (remote_debug)
 639     {
 640       ConsolePrintf ("vector=%d: %s, sr=%08x, pc=%08x, thread=%08x\r\n",
 641                      frame->ExceptionNumber,
 642                      frame->ExceptionDescription,
 643                      frame->ExceptionSystemFlags,
 644                      frame->ExceptionPC,
 645                      GetThreadID ());
 646     }
 647
 648   switch (frame->ExceptionNumber)
 649     {
 650     case START_NLM_EVENT:
 651       /* If the NLM just started, we record the module load information
 652          and the thread ID, and set a breakpoint at the first instruction
 653          in the program.  */
 654
 655       ldinfo = ((struct DBG_LoadDefinitionStructure *)
 656                 frame->ExceptionErrorCode);
 657       memcpy (first_insn, ldinfo->LDInitializationProcedure,
 658               BREAKPOINT_SIZE);
 659       memcpy (ldinfo->LDInitializationProcedure, breakpoint_insn,
 660               BREAKPOINT_SIZE);
 661       flush_i_cache ();
 662       return RETURN_TO_PROGRAM;
 663
 664     case TERMINATE_NLM_EVENT:
 665       if (!killed)
 666         {
 667           /* NetWare processes don't have an exit status so we
 668              generate our own  */
 669           sprintf (remcomOutBuffer, "W%02x", 0);
 670           putpacket(remcomOutBuffer);
 671         }
 672       ResumeThread (mainthread);
 673       return RETURN_TO_PROGRAM;
 674
 675     case ENTER_DEBUGGER_EVENT:
 676     case KEYBOARD_BREAK_EVENT:
 677       /* Pass some events on to the next debugger, in case it will handle
 678          them.  */
 679       return RETURN_TO_NEXT_DEBUGGER;
 680
 681     case 3:                     /* Breakpoint */
 682       /* After we've reached the initial breakpoint, reset it.  */
 683       if (frame->ExceptionPC - DECR_PC_AFTER_BREAK == (LONG) ldinfo->LDInitializationProcedure
 684           && memcmp (ldinfo->LDInitializationProcedure, breakpoint_insn,
 685                      BREAKPOINT_SIZE) == 0)
 686         {
 687           memcpy (ldinfo->LDInitializationProcedure, first_insn,
 688                   BREAKPOINT_SIZE);
 689           frame->ExceptionPC -= DECR_PC_AFTER_BREAK;
 690           flush_i_cache ();
 691         }
 692       /* Normal breakpoints end up here */
 693       do_status (remcomOutBuffer, frame);
 694       break;
 695
 696     default:
 697       /* At the moment, we don't care about most of the unusual NetWare
 698          exceptions.  */
 699       if (frame->ExceptionNumber > 31)
 700         return RETURN_TO_PROGRAM;
 701
 702       /* Most machine level exceptions end up here */
 703       do_status (remcomOutBuffer, frame);
 704       break;
 705
 706     case 11:                    /* Segment not present */
 707     case 13:                    /* General protection */
 708     case 14:                    /* Page fault */
 709       /* If we get a GP fault, and mem_may_fault is set, and the
 710          instruction pointer is near set_char or get_char, then we caused
 711          the fault ourselves accessing an illegal memory location.  */
 712       if (mem_may_fault
 713           && ((frame->ExceptionPC >= (long) &set_char
 714                && frame->ExceptionPC < (long) &set_char + 50)
 715               || (frame->ExceptionPC >= (long) &get_char
 716                   && frame->ExceptionPC < (long) &get_char + 50)))
 717         {
 718           mem_err = 1;
 719           /* Point the instruction pointer at an assembly language stub
 720              which just returns from the function.  */
 721
 722           frame->ExceptionPC = (long) &just_return;
 723
 724           /* Keep going.  This will act as though it returned from
 725              set_char or get_char.  The calling routine will check
 726              mem_err, and do the right thing.  */
 727           return RETURN_TO_PROGRAM;
 728         }
 729       /* Random mem fault, report it */
 730       do_status (remcomOutBuffer, frame);
 731       break;
 732     }
 733
 734   /* FIXME: How do we know that this exception has anything to do with
 735      the program we are debugging?  We can check whether the PC is in
 736      the range of the module we are debugging, but that doesn't help
 737      much since an error could occur in a library routine.  */
 738
 739   clear_step_traps (frame);
 740
 741   if (! putpacket(remcomOutBuffer))
 742     return RETURN_TO_NEXT_DEBUGGER;
 743
 744   while (1)
 745     {
 746       error = 0;
 747       remcomOutBuffer[0] = 0;
 748       if (! getpacket (remcomInBuffer))
 749         return RETURN_TO_NEXT_DEBUGGER;
 750       switch (remcomInBuffer[0])
 751         {
 752         case '?':
 753           do_status (remcomOutBuffer, frame);
 754           break;
 755         case 'd':
 756           remote_debug = !(remote_debug); /* toggle debug flag */
 757           break;
 758         case 'g':
 759           /* return the value of the CPU registers */
 760           frame_to_registers (frame, remcomOutBuffer);
 761           break;
 762         case 'G':
 763           /* set the value of the CPU registers - return OK */
 764           registers_to_frame (&remcomInBuffer[1], frame);
 765           strcpy(remcomOutBuffer,"OK");
 766           break;
 767
 768         case 'm':
 769           /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
 770           /* TRY TO READ %x,%x.  IF SUCCEED, SET PTR = 0 */
 771           ptr = &remcomInBuffer[1];
 772           if (hexToInt(&ptr,&addr))
 773             if (*(ptr++) == ',')
 774               if (hexToInt(&ptr,&length))
 775                 {
 776                   ptr = 0;
 777                   mem_err = 0;
 778                   mem2hex((char*) addr, remcomOutBuffer, length, 1);
 779                   if (mem_err)
 780                     {
 781                       strcpy (remcomOutBuffer, "E03");
 782                       debug_error ("memory fault");
 783                     }
 784                 }
 785
 786           if (ptr)
 787             {
 788               strcpy(remcomOutBuffer,"E01");
 789               debug_error("malformed read memory command: %s",remcomInBuffer);
 790             }
 791           break;
 792
 793         case 'M':
 794           /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
 795           /* TRY TO READ '%x,%x:'.  IF SUCCEED, SET PTR = 0 */
 796           ptr = &remcomInBuffer[1];
 797           if (hexToInt(&ptr,&addr))
 798             if (*(ptr++) == ',')
 799               if (hexToInt(&ptr,&length))
 800                 if (*(ptr++) == ':')
 801                   {
 802                     mem_err = 0;
 803                     hex2mem(ptr, (char*) addr, length, 1);
 804
 805                     if (mem_err)
 806                       {
 807                         strcpy (remcomOutBuffer, "E03");
 808                         debug_error ("memory fault");
 809                       }
 810                     else
 811                       {
 812                         strcpy(remcomOutBuffer,"OK");
 813                       }
 814
 815                     ptr = 0;
 816                   }
 817           if (ptr)
 818             {
 819               strcpy(remcomOutBuffer,"E02");
 820               debug_error("malformed write memory command: %s",remcomInBuffer);
 821             }
 822           break;
 823
 824         case 'c':
 825         case 's':
 826           /* cAA..AA    Continue at address AA..AA(optional) */
 827           /* sAA..AA   Step one instruction from AA..AA(optional) */
 828           /* try to read optional parameter, pc unchanged if no parm */
 829           ptr = &remcomInBuffer[1];
 830           if (hexToInt(&ptr,&addr))
 831             {
 832 /*            registers[PC_REGNUM].lo = addr;*/
 833               ConsolePrintf("Setting PC to 0x%x\n", addr);
 834               while (1);
 835             }
 836
 837           if (remcomInBuffer[0] == 's')
 838             set_step_traps (frame);
 839
 840           flush_i_cache ();
 841           return RETURN_TO_PROGRAM;
 842
 843         case 'k':
 844           /* The undocumented netware call KillMe() is supposed to
 845              schedule the NLM to be killed when it next blocks.  What
 846              really happens is that the server hangs as it tries to
 847              unload the NLM.
 848
 849              So, since netware won't cooperate, we just point the PC
 850              at the start of _exit() and continue, while noting that
 851              we've killed the process.  */
 852
 853           killed = 1;
 854           frame->ExceptionPC = &_exit;
 855           return RETURN_TO_PROGRAM;
 856
 857         case 'q':               /* Query message */
 858           if (strcmp (&remcomInBuffer[1], "Offsets") == 0)
 859             {
 860               sprintf (remcomOutBuffer, "Text=%x;Data=%x;Bss=%x",
 861                        ldinfo->LDCodeImageOffset,
 862                        ldinfo->LDDataImageOffset,
 863                        ldinfo->LDDataImageOffset + ldinfo->LDDataImageLength);
 864             }
 865           else
 866             sprintf (remcomOutBuffer, "E04, Unknown query %s", &remcomInBuffer[1]);
 867           break;
 868         }
 869
 870       /* reply to the request */
 871       if (! putpacket(remcomOutBuffer))
 872         return RETURN_TO_NEXT_DEBUGGER;
 873     }
 874 }
 875
 876
 877 char *progname;
 878
 879 struct bitRate {
 880   BYTE bitRate;
 881   const char *bitRateString;
 882 };
 883
 884 struct bitRate bitRateTable[] =
 885 {
 886   { AIO_BAUD_50    ,      "50" },
 887   { AIO_BAUD_75    ,      "75" },
 888   { AIO_BAUD_110   ,     "110" },
 889   { AIO_BAUD_134p5 ,   "134.5" },
 890   { AIO_BAUD_150   ,     "150" },
 891   { AIO_BAUD_300   ,     "300" },
 892   { AIO_BAUD_600   ,     "600" },
 893   { AIO_BAUD_1200  ,    "1200" },
 894   { AIO_BAUD_1800  ,    "1800" },
 895   { AIO_BAUD_2000  ,    "2000" },
 896   { AIO_BAUD_2400  ,    "2400" },
 897   { AIO_BAUD_3600  ,    "3600" },
 898   { AIO_BAUD_4800  ,    "4800" },
 899   { AIO_BAUD_7200  ,    "7200" },
 900   { AIO_BAUD_9600  ,    "9600" },
 901   { AIO_BAUD_19200 ,   "19200" },
 902   { AIO_BAUD_38400 ,   "38400" },
 903   { AIO_BAUD_57600 ,   "57600" },
 904   { AIO_BAUD_115200,  "115200" },
 905   { -1, NULL }
 906 };
 907
 908 char dataBitsTable[] = "5678";
 909
 910 char *stopBitsTable[] = { "1", "1.5", "2" };
 911
 912 char parity[] = "NOEMS";
 913
 914 /* Start up.  The main thread opens the named serial I/O port, loads
 915    the named NLM module and then goes to sleep.  The serial I/O port
 916    is named as a board number and a port number.  It would be more DOS
 917    like to provide a menu of available serial ports, but I don't want
 918    to have to figure out how to do that.  */
 919
 920 int
 921 main (argc, argv)
 922      int argc;
 923      char **argv;
 924 {
 925   int hardware, board, port;
 926   BYTE bitRate;
 927   BYTE dataBits;
 928   BYTE stopBits;
 929   BYTE parityMode;
 930   LONG err;
 931   struct debuggerStructure s;
 932   int cmdindx;
 933   char *cmdlin;
 934   int i;
 935
 936   /* set progname */
 937   progname = "nlmstub";
 938
 939   hardware = -1;
 940   board = 0;
 941   port = 0;
 942
 943   /* set default serial line characteristics */
 944   bitRate  = AIO_BAUD_9600;
 945   dataBits = AIO_DATA_BITS_8;
 946   stopBits = AIO_STOP_BITS_1;
 947   parityMode = AIO_PARITY_NONE;
 948
 949   cmdindx = 0;
 950   for (argc--, argv++; *argv; argc--, argv++)
 951     {
 952       char *bp;
 953       char *ep;
 954
 955       if (strnicmp(*argv, "BAUD=", 5) == 0)
 956         {
 957           struct bitRate *brp;
 958
 959           bp = *argv + 5;
 960           for (brp = bitRateTable; brp->bitRate != (BYTE) -1; brp++)
 961             {
 962               if (strcmp(brp->bitRateString, bp) == 0)
 963                 {
 964                   bitRate = brp->bitRate;
 965                   break;
 966                 }
 967             }
 968
 969           if (brp->bitRateString == NULL)
 970             {
 971               fprintf(stderr, "%s: %s: unknown or unsupported bit rate",
 972                       progname, bp);
 973               exit (1);
 974             }
 975         }
 976       else if (strnicmp(*argv, "NODE=", 5) == 0)
 977         {
 978           bp = *argv + 5;
 979           board = strtol (bp, &ep, 0);
 980           if (ep == bp || *ep != '\0')
 981             {
 982               fprintf (stderr, "%s: %s: expected integer argument\n",
 983                        progname, bp);
 984               exit(1);
 985             }
 986         }
 987       else if (strnicmp(*argv, "PORT=", 5) == 0)
 988         {
 989           bp = *argv + 5;
 990           port = strtol (bp, &ep, 0);
 991           if (ep == bp || *ep != '\0')
 992             {
 993               fprintf (stderr, "%s: %s: expected integer argument\n",
 994                        progname, bp);
 995               exit(1);
 996             }
 997         }
 998       else
 999         {
1000           break;
1001         }
1002
1003       cmdindx++;
1004     }
1005
1006   if (argc == 0)
1007     {
1008       fprintf (stderr,
1009                "Usage: load %s [options] program [arguments]\n", progname);
1010       exit (1);
1011     }
1012
1013   err = AIOAcquirePort (&hardware, &board, &port, &AIOhandle);
1014   if (err != AIO_SUCCESS)
1015     {
1016       switch (err)
1017         {
1018         case AIO_PORT_NOT_AVAILABLE:
1019           fprintf (stderr, "Port not available\n");
1020           break;
1021
1022         case AIO_BOARD_NUMBER_INVALID:
1023         case AIO_PORT_NUMBER_INVALID:
1024           fprintf (stderr, "No such port\n");
1025           break;
1026
1027         default:
1028           fprintf (stderr, "Could not open port: %d\n", err);
1029           break;
1030         }
1031
1032       exit (1);
1033     }
1034
1035   err = AIOConfigurePort (AIOhandle, bitRate, dataBits, stopBits, parityMode,
1036                           AIO_HARDWARE_FLOW_CONTROL_OFF);
1037
1038   if (err == AIO_QUALIFIED_SUCCESS)
1039     {
1040       AIOPORTCONFIG portConfig;
1041
1042       fprintf (stderr, "Port configuration changed!\n");
1043
1044       portConfig.returnLength = sizeof(portConfig);
1045       AIOGetPortConfiguration (AIOhandle, &portConfig, NULL);
1046
1047       fprintf (stderr,
1048                "  Bit Rate: %s, Data Bits: %c, Stop Bits: %s, Parity: %c,\
1049  Flow:%s\n",
1050                bitRateTable[portConfig.bitRate].bitRateString,
1051                dataBitsTable[portConfig.dataBits],
1052                stopBitsTable[portConfig.stopBits],
1053                parity[portConfig.parityMode],
1054                portConfig.flowCtrlMode ? "ON" : "OFF");
1055     }
1056   else if (err != AIO_SUCCESS)
1057     {
1058       fprintf (stderr, "Could not configure port: %d\n", err);
1059       AIOReleasePort (AIOhandle);
1060       exit (1);
1061     }
1062
1063   if (AIOSetExternalControl(AIOhandle, AIO_EXTERNAL_CONTROL,
1064                             (AIO_EXTCTRL_DTR | AIO_EXTCTRL_RTS))
1065       != AIO_SUCCESS)
1066     {
1067       LONG extStatus, chgdExtStatus;
1068
1069       fprintf (stderr, "Could not set desired port controls!\n");
1070       AIOGetExternalStatus (AIOhandle, &extStatus, &chgdExtStatus);
1071       fprintf (stderr, "Port controls now: %d, %d\n", extStatus,
1072                chgdExtStatus);
1073     }
1074
1075   /* Register ourselves as an alternate debugger.  */
1076   memset (&s, 0, sizeof s);
1077   s.DDSResourceTag = ((struct ResourceTagStructure *)
1078                       AllocateResourceTag (GetNLMHandle (),
1079                                            (BYTE *)"gdbserver",
1080                                            DebuggerSignature));
1081   if (s.DDSResourceTag == 0)
1082     {
1083       fprintf (stderr, "AllocateResourceTag failed\n");
1084       AIOReleasePort (AIOhandle);
1085       exit (1);
1086     }
1087   s.DDSdebuggerEntry = handle_exception;
1088   s.DDSFlags = TSS_FRAME_BIT;
1089
1090   err = RegisterDebuggerRTag (&s, AT_FIRST);
1091   if (err != 0)
1092     {
1093       fprintf (stderr, "RegisterDebuggerRTag failed\n");
1094       AIOReleasePort (AIOhandle);
1095       exit (1);
1096     }
1097
1098   /* Get the command line we were invoked with, and advance it past
1099      our name and command line arguments.  */
1100   cmdlin = getcmd ((char *) NULL);
1101   for (i = 0; i < cmdindx; i++)
1102     {
1103       while (! isspace (*cmdlin))
1104         cmdlin++;
1105       while (isspace (*cmdlin))
1106         cmdlin++;
1107     }
1108
1109   /* In case GDB is started before us, ack any packets (presumably
1110      "$?#xx") sitting there.  */
1111   if (! putDebugChar ('+'))
1112     {
1113       fprintf (stderr, "putDebugChar failed\n");
1114       UnRegisterDebugger (&s);
1115       AIOReleasePort (AIOhandle);
1116       exit (1);
1117     }
1118
1119   mainthread = GetThreadID ();
1120
1121   if (remote_debug > 0)
1122     ConsolePrintf ("About to call LoadModule with \"%s\" %08x\r\n",
1123                    cmdlin, __GetScreenID (GetCurrentScreen()));
1124
1125   /* Start up the module to be debugged.  */
1126   err = LoadModule ((struct ScreenStruct *) __GetScreenID (GetCurrentScreen()),
1127                     (BYTE *)cmdlin, LO_DEBUG);
1128   if (err != 0)
1129     {
1130       fprintf (stderr, "LoadModule failed: %d\n", err);
1131       UnRegisterDebugger (&s);
1132       AIOReleasePort (AIOhandle);
1133       exit (1);
1134     }
1135
1136   /* Wait for the debugger to wake us up.  */
1137   if (remote_debug > 0)
1138     ConsolePrintf ("Suspending main thread (%08x)\r\n", mainthread);
1139   SuspendThread (mainthread);
1140   if (remote_debug > 0)
1141     ConsolePrintf ("Resuming main thread (%08x)\r\n", mainthread);
1142
1143   /* If we are woken up, print an optional error message, deregister
1144      ourselves and exit.  */
1145   if (error_message != NULL)
1146     fprintf (stderr, "%s\n", error_message);
1147   UnRegisterDebugger (&s);
1148   AIOReleasePort (AIOhandle);
1149   exit (0);
1150 }