1 /* i386-nlmstub.c -- NLM debugging stub for the i386.
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.
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. */
14 /****************************************************************************
16 THIS SOFTWARE IS NOT COPYRIGHTED
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.
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.
26 ****************************************************************************/
28 /****************************************************************************
30 * The following gdb commands are supported:
32 * command function Return value
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
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
40 * c Resume at current address SNN ( signal NN)
41 * cAA..AA Continue at address AA..AA SNN
43 * s Step one instruction SNN
44 * sAA..AA Step one instruction from AA..AA SNN
48 * ? What was the last sigval ? SNN (signal NN)
50 * All commands and responses are sent with a packet which includes a
51 * checksum. A packet consists of
53 * $<packet info>#<checksum>.
56 * <packet info> :: <characters representing the command or response>
57 * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>>
59 * When a packet is received, it is first acknowledged with either '+' or '-'.
60 * '+' indicates a successful transfer. '-' indicates a failed transfer.
65 * $m0,10#2a +$00010203040506070809101112131415#42
67 ****************************************************************************/
82 /****************************************************/
83 /* This information is from Novell. It is not in any of the standard
84 NetWare header files. */
86 struct DBG_LoadDefinitionStructure
90 LONG LDCodeImageOffset
;
91 LONG LDCodeImageLength
;
92 LONG LDDataImageOffset
;
93 LONG LDDataImageLength
;
94 LONG LDUninitializedDataLength
;
95 LONG LDCustomDataOffset
;
96 LONG LDCustomDataSize
;
98 LONG (*LDInitializationProcedure
)(void);
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
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 /****************************************************/
124 /* The main thread ID. */
125 static int mainthread
;
127 /* An error message for the main thread to print. */
128 static char *error_message
;
130 /* The AIO port handle. */
131 static int AIOhandle
;
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)
137 /* remote_debug > 0 prints ill-formed commands in valid packets and
139 static int remote_debug
= 1;
141 static const char hexchars
[] = "0123456789abcdef";
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 */
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
155 unsigned char breakpoint_insn
[] = BREAKPOINT
;
156 #define BREAKPOINT_SIZE (sizeof breakpoint_insn)
158 static void flush_i_cache() {}
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
*);
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. */
181 err
= AIOReadData (AIOhandle
, (char *) &ret
, 1, &got
);
184 error_message
= "AIOReadData failed";
185 ResumeThread (mainthread
);
194 /* Write a character to the serial port. Returns 0 on failure,
195 non-zero on success. */
207 err
= AIOWriteData (AIOhandle
, (char *) &c
, 1, &put
);
209 ConsolePrintf ("AIOWriteData: err = %d, put = %d\r\n", err
, put
);
214 /* Get the registers out of the frame information. */
217 frame_to_registers (frame
, regs
)
218 struct StackFrame
*frame
;
221 /* Copy EAX -> EDI */
222 mem2hex (&frame
->ExceptionEAX
, ®s
[0 * 4 * 2], 4 * 8, 0);
225 mem2hex (&frame
->ExceptionPC
, ®s
[8 * 4 * 2], 4 * 2, 0);
227 /* Copy CS, SS, DS */
228 mem2hex (&frame
->ExceptionCS
, ®s
[10 * 4 * 2], 4 * 3, 0);
231 mem2hex (&frame
->ExceptionES
, ®s
[13 * 4 * 2], 4 * 1, 0);
234 mem2hex (&frame
->ExceptionFS
, ®s
[14 * 4 * 2], 4 * 2, 0);
237 /* Put the registers back into the frame information. */
240 registers_to_frame (regs
, frame
)
242 struct StackFrame
*frame
;
244 /* Copy EAX -> EDI */
245 hex2mem (®s
[0 * 4 * 2], &frame
->ExceptionEAX
, 4 * 8, 0);
248 hex2mem (®s
[8 * 4 * 2], &frame
->ExceptionPC
, 4 * 2, 0);
250 /* Copy CS, SS, DS */
251 hex2mem (®s
[10 * 4 * 2], &frame
->ExceptionCS
, 4 * 3, 0);
254 hex2mem (®s
[13 * 4 * 2], &frame
->ExceptionES
, 4 * 1, 0);
257 hex2mem (®s
[14 * 4 * 2], &frame
->ExceptionFS
, 4 * 2, 0);
260 /* Turn a hex character into a number. */
266 if ((ch
>= 'a') && (ch
<= 'f'))
268 if ((ch
>= '0') && (ch
<= '9'))
270 if ((ch
>= 'A') && (ch
<= 'F'))
275 /* Scan for the sequence $<data>#<checksum>. Returns 0 on failure,
276 non-zero on success. */
282 unsigned char checksum
;
283 unsigned char xmitcsum
;
290 /* wait around for the start character, ignore all other characters */
291 while ((ch
= getDebugChar()) != '$')
299 /* now, read until a # or end of buffer is found */
300 while (count
< BUFMAX
)
307 checksum
= checksum
+ ch
;
315 ch
= getDebugChar ();
318 xmitcsum
= hex(ch
) << 4;
319 ch
= getDebugChar ();
324 if (checksum
!= xmitcsum
)
327 ConsolePrintf ("bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
328 checksum
,xmitcsum
,buffer
);
329 /* failed checksum */
330 if (! putDebugChar('-'))
336 /* successful transfer */
337 if (! putDebugChar('+'))
339 /* if a sequence char is present, reply the sequence ID */
340 if (buffer
[2] == ':')
342 if (! putDebugChar (buffer
[0])
343 || ! putDebugChar (buffer
[1]))
345 /* remove sequence chars from buffer */
346 count
= strlen(buffer
);
347 for (i
=3; i
<= count
; i
++)
348 buffer
[i
-3] = buffer
[i
];
353 while (checksum
!= xmitcsum
);
356 ConsolePrintf ("Received packet \"%s\"\r\n", buffer
);
361 /* Send the packet in buffer. Returns 0 on failure, non-zero on
368 unsigned char checksum
;
373 ConsolePrintf ("Sending packet \"%s\"\r\n", buffer
);
375 /* $<packet info>#<checksum>. */
378 if (! putDebugChar('$'))
383 while (ch
=buffer
[count
])
385 if (! putDebugChar(ch
))
391 if (! putDebugChar('#')
392 || ! putDebugChar(hexchars
[checksum
>> 4])
393 || ! putDebugChar(hexchars
[checksum
% 16]))
396 ch
= getDebugChar ();
405 static char remcomInBuffer
[BUFMAX
];
406 static char remcomOutBuffer
[BUFMAX
];
410 debug_error (format
, parm
)
416 ConsolePrintf (format
, parm
);
417 ConsolePrintf ("\n");
421 /* This is set if we could get a memory access fault. */
422 static int mem_may_fault
;
424 /* Indicate to caller of mem2hex or hex2mem that there has been an
426 static volatile int mem_err
= 0;
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
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. */
452 extern void just_return ();
453 asm (".globl just_return");
454 asm (".globl _just_return");
455 asm ("just_return:");
456 asm ("_just_return:");
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. */
466 mem2hex (mem
, buf
, count
, may_fault
)
476 mem_may_fault
= may_fault
;
477 for (i
= 0; i
< count
; i
++)
479 ch
= get_char (ptr
++);
480 if (may_fault
&& mem_err
)
482 *buf
++ = hexchars
[ch
>> 4];
483 *buf
++ = hexchars
[ch
% 16];
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 */
494 hex2mem (buf
, mem
, count
, may_fault
)
504 mem_may_fault
= may_fault
;
505 for (i
=0;i
<count
;i
++)
507 ch
= hex(*buf
++) << 4;
508 ch
= ch
+ hex(*buf
++);
509 set_char (ptr
++, ch
);
510 if (may_fault
&& mem_err
)
517 /* This function takes the 386 exception vector and attempts to
518 translate this number into a unix compatible signal value. */
521 computeSignal (exceptionVector
)
525 switch (exceptionVector
)
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 */
543 sigval
= 7; /* "software generated"*/
548 /**********************************************/
549 /* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
550 /* RETURN NUMBER OF CHARS PROCESSED */
551 /**********************************************/
553 hexToInt(ptr
, intValue
)
564 hexValue
= hex(**ptr
);
567 *intValue
= (*intValue
<<4) | hexValue
;
580 set_step_traps (frame
)
581 struct StackFrame
*frame
;
583 frame
->ExceptionSystemFlags
|= 0x100;
587 clear_step_traps (frame
)
588 struct StackFrame
*frame
;
590 frame
->ExceptionSystemFlags
&= ~0x100;
594 do_status (ptr
, frame
)
596 struct StackFrame
*frame
;
600 sigval
= computeSignal (frame
->ExceptionNumber
);
602 sprintf (ptr
, "T%02x", sigval
);
605 sprintf (ptr
, "%02x:", PC_REGNUM
);
606 ptr
= mem2hex (&frame
->ExceptionPC
, ptr
+ 3, 4, 0);
609 sprintf (ptr
, "%02x:", SP_REGNUM
);
610 ptr
= mem2hex (&frame
->ExceptionESP
, ptr
+ 3, 4, 0);
613 sprintf (ptr
, "%02x:", FP_REGNUM
);
614 ptr
= mem2hex (&frame
->ExceptionEBP
, ptr
+ 3, 4, 0);
620 /* This function does all command processing for interfacing to gdb.
621 It is called whenever an exception occurs in the module being
625 handle_exception (frame
)
626 struct StackFrame
*frame
;
630 static struct DBG_LoadDefinitionStructure
*ldinfo
= 0;
631 static unsigned char first_insn
[BREAKPOINT_SIZE
]; /* The first instruction in the program. */
633 /* Apparently the bell can sometimes be ringing at this point, and
634 should be stopped. */
639 ConsolePrintf ("vector=%d: %s, sr=%08x, pc=%08x, thread=%08x\r\n",
640 frame
->ExceptionNumber
,
641 frame
->ExceptionDescription
,
642 frame
->ExceptionSystemFlags
,
647 switch (frame
->ExceptionNumber
)
649 case START_NLM_EVENT
:
650 /* If the NLM just started, we record the module load information
651 and the thread ID, and set a breakpoint at the first instruction
654 ldinfo
= ((struct DBG_LoadDefinitionStructure
*)
655 frame
->ExceptionErrorCode
);
656 memcpy (first_insn
, ldinfo
->LDInitializationProcedure
,
658 memcpy (ldinfo
->LDInitializationProcedure
, breakpoint_insn
,
661 return RETURN_TO_PROGRAM
;
663 case ENTER_DEBUGGER_EVENT
:
664 case KEYBOARD_BREAK_EVENT
:
665 /* Pass some events on to the next debugger, in case it will handle
667 return RETURN_TO_NEXT_DEBUGGER
;
669 case 3: /* Breakpoint */
670 /* After we've reached the initial breakpoint, reset it. */
671 if (frame
->ExceptionPC
- DECR_PC_AFTER_BREAK
== (LONG
) ldinfo
->LDInitializationProcedure
672 && memcmp (ldinfo
->LDInitializationProcedure
, breakpoint_insn
,
673 BREAKPOINT_SIZE
) == 0)
675 memcpy (ldinfo
->LDInitializationProcedure
, first_insn
,
677 frame
->ExceptionPC
-= DECR_PC_AFTER_BREAK
;
680 /* Normal breakpoints end up here */
681 do_status (remcomOutBuffer
, frame
);
685 /* At the moment, we don't care about most of the unusual NetWare
687 if (frame
->ExceptionNumber
> 31)
688 return RETURN_TO_PROGRAM
;
690 /* Most machine level exceptions end up here */
691 do_status (remcomOutBuffer
, frame
);
694 case 11: /* Segment not present */
695 case 13: /* General protection */
696 case 14: /* Page fault */
697 /* If we get a GP fault, and mem_may_fault is set, and the
698 instruction pointer is near set_char or get_char, then we caused
699 the fault ourselves accessing an illegal memory location. */
701 && ((frame
->ExceptionPC
>= (long) &set_char
702 && frame
->ExceptionPC
< (long) &set_char
+ 50)
703 || (frame
->ExceptionPC
>= (long) &get_char
704 && frame
->ExceptionPC
< (long) &get_char
+ 50)))
707 /* Point the instruction pointer at an assembly language stub
708 which just returns from the function. */
710 frame
->ExceptionPC
= (long) &just_return
;
712 /* Keep going. This will act as though it returned from
713 set_char or get_char. The calling routine will check
714 mem_err, and do the right thing. */
715 return RETURN_TO_PROGRAM
;
717 /* Random mem fault, report it */
718 do_status (remcomOutBuffer
, frame
);
721 case TERMINATE_NLM_EVENT
:
722 /* There is no way to get the exit status. */
723 sprintf (remcomOutBuffer
, "W%02x", 0);
724 break; /* We generate our own status */
727 /* FIXME: How do we know that this exception has anything to do with
728 the program we are debugging? We can check whether the PC is in
729 the range of the module we are debugging, but that doesn't help
730 much since an error could occur in a library routine. */
732 clear_step_traps (frame
);
734 if (! putpacket(remcomOutBuffer
))
735 return RETURN_TO_NEXT_DEBUGGER
;
737 if (frame
->ExceptionNumber
== TERMINATE_NLM_EVENT
)
739 ResumeThread (mainthread
);
740 return RETURN_TO_PROGRAM
;
746 remcomOutBuffer
[0] = 0;
747 if (! getpacket (remcomInBuffer
))
748 return RETURN_TO_NEXT_DEBUGGER
;
749 switch (remcomInBuffer
[0])
752 do_status (remcomOutBuffer
, frame
);
755 remote_debug
= !(remote_debug
); /* toggle debug flag */
758 /* return the value of the CPU registers */
759 frame_to_registers (frame
, remcomOutBuffer
);
762 /* set the value of the CPU registers - return OK */
763 registers_to_frame (&remcomInBuffer
[1], frame
);
764 strcpy(remcomOutBuffer
,"OK");
768 /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
769 /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
770 ptr
= &remcomInBuffer
[1];
771 if (hexToInt(&ptr
,&addr
))
773 if (hexToInt(&ptr
,&length
))
777 mem2hex((char*) addr
, remcomOutBuffer
, length
, 1);
780 strcpy (remcomOutBuffer
, "E03");
781 debug_error ("memory fault");
787 strcpy(remcomOutBuffer
,"E01");
788 debug_error("malformed read memory command: %s",remcomInBuffer
);
793 /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
794 /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
795 ptr
= &remcomInBuffer
[1];
796 if (hexToInt(&ptr
,&addr
))
798 if (hexToInt(&ptr
,&length
))
802 hex2mem(ptr
, (char*) addr
, length
, 1);
806 strcpy (remcomOutBuffer
, "E03");
807 debug_error ("memory fault");
811 strcpy(remcomOutBuffer
,"OK");
818 strcpy(remcomOutBuffer
,"E02");
819 debug_error("malformed write memory command: %s",remcomInBuffer
);
825 /* cAA..AA Continue at address AA..AA(optional) */
826 /* sAA..AA Step one instruction from AA..AA(optional) */
827 /* try to read optional parameter, pc unchanged if no parm */
828 ptr
= &remcomInBuffer
[1];
829 if (hexToInt(&ptr
,&addr
))
831 /* registers[PC_REGNUM].lo = addr;*/
832 fprintf (stderr
, "Setting PC to 0x%x\n", addr
);
836 if (remcomInBuffer
[0] == 's')
837 set_step_traps (frame
);
840 return RETURN_TO_PROGRAM
;
843 /* kill the program */
845 ResumeThread (mainthread
);
846 return RETURN_TO_PROGRAM
;
848 case 'q': /* Query message */
849 if (strcmp (&remcomInBuffer
[1], "Offsets") == 0)
851 sprintf (remcomOutBuffer
, "Text=%x;Data=%x;Bss=%x",
852 ldinfo
->LDCodeImageOffset
,
853 ldinfo
->LDDataImageOffset
,
854 ldinfo
->LDDataImageOffset
+ ldinfo
->LDDataImageLength
);
857 sprintf (remcomOutBuffer
, "E04, Unknown query %s", &remcomInBuffer
[1]);
861 /* reply to the request */
862 if (! putpacket(remcomOutBuffer
))
863 return RETURN_TO_NEXT_DEBUGGER
;
872 const char *bitRateString
;
875 struct bitRate bitRateTable
[] =
877 { AIO_BAUD_50
, "50" },
878 { AIO_BAUD_75
, "75" },
879 { AIO_BAUD_110
, "110" },
880 { AIO_BAUD_134p5
, "134.5" },
881 { AIO_BAUD_150
, "150" },
882 { AIO_BAUD_300
, "300" },
883 { AIO_BAUD_600
, "600" },
884 { AIO_BAUD_1200
, "1200" },
885 { AIO_BAUD_1800
, "1800" },
886 { AIO_BAUD_2000
, "2000" },
887 { AIO_BAUD_2400
, "2400" },
888 { AIO_BAUD_3600
, "3600" },
889 { AIO_BAUD_4800
, "4800" },
890 { AIO_BAUD_7200
, "7200" },
891 { AIO_BAUD_9600
, "9600" },
892 { AIO_BAUD_19200
, "19200" },
893 { AIO_BAUD_38400
, "38400" },
894 { AIO_BAUD_57600
, "57600" },
895 { AIO_BAUD_115200
, "115200" },
899 char dataBitsTable
[] = "5678";
901 char *stopBitsTable
[] = { "1", "1.5", "2" };
903 char parity
[] = "NOEMS";
905 /* Start up. The main thread opens the named serial I/O port, loads
906 the named NLM module and then goes to sleep. The serial I/O port
907 is named as a board number and a port number. It would be more DOS
908 like to provide a menu of available serial ports, but I don't want
909 to have to figure out how to do that. */
916 int hardware
, board
, port
;
922 struct debuggerStructure s
;
928 progname
= "nlmstub";
934 /* set default serial line characteristics */
935 bitRate
= AIO_BAUD_9600
;
936 dataBits
= AIO_DATA_BITS_8
;
937 stopBits
= AIO_STOP_BITS_1
;
938 parityMode
= AIO_PARITY_NONE
;
941 for (argc
--, argv
++; *argv
; argc
--, argv
++)
946 if (strncmp(*argv
, "BAUD=", 5) == 0)
951 for (brp
= bitRateTable
; brp
->bitRateString
!= NULL
; brp
++)
953 if (strcmp(brp
->bitRateString
, bp
) == 0)
955 bitRate
= brp
->bitRate
;
960 if (brp
->bitRateString
== NULL
)
962 fprintf(stderr
, "%s: %s: unknown or unsupported bit rate",
967 else if (strncmp(*argv
, "NODE=", 5) == 0)
970 board
= strtol (bp
, &ep
, 0);
971 if (ep
== bp
|| *ep
!= '\0')
973 fprintf (stderr
, "%s: %s: expected integer argument\n",
978 else if (strncmp(*argv
, "PORT=", 5) == 0)
981 port
= strtol (bp
, &ep
, 0);
982 if (ep
== bp
|| *ep
!= '\0')
984 fprintf (stderr
, "%s: %s: expected integer argument\n",
1000 "Usage: load %s [options] program [arguments]\n", progname
);
1004 err
= AIOAcquirePort (&hardware
, &board
, &port
, &AIOhandle
);
1005 if (err
!= AIO_SUCCESS
)
1009 case AIO_PORT_NOT_AVAILABLE
:
1010 fprintf (stderr
, "Port not available\n");
1013 case AIO_BOARD_NUMBER_INVALID
:
1014 case AIO_PORT_NUMBER_INVALID
:
1015 fprintf (stderr
, "No such port\n");
1019 fprintf (stderr
, "Could not open port: %d\n", err
);
1026 err
= AIOConfigurePort (AIOhandle
, bitRate
, dataBits
, stopBits
, parityMode
,
1027 AIO_HARDWARE_FLOW_CONTROL_OFF
);
1029 if (err
== AIO_QUALIFIED_SUCCESS
)
1031 AIOPORTCONFIG portConfig
;
1032 AIODVRCONFIG dvrConfig
;
1034 fprintf (stderr
, "Port configuration changed!\n");
1035 AIOGetPortConfiguration (AIOhandle
, &portConfig
, &dvrConfig
);
1037 " Bit Rate: %s, Data Bits: %c, Stop Bits: %s, Parity: %c,\
1039 bitRateTable
[portConfig
.bitRate
],
1040 dataBitsTable
[portConfig
.dataBits
],
1041 stopBitsTable
[portConfig
.stopBits
],
1042 parity
[portConfig
.parityMode
],
1043 portConfig
.flowCtrlMode
? "ON" : "OFF");
1045 else if (err
!= AIO_SUCCESS
)
1047 fprintf (stderr
, "Could not configure port: %d\n", err
);
1048 AIOReleasePort (AIOhandle
);
1052 if (AIOSetExternalControl(AIOhandle
, AIO_EXTERNAL_CONTROL
,
1053 (AIO_EXTCTRL_DTR
| AIO_EXTCTRL_RTS
))
1056 LONG extStatus
, chgdExtStatus
;
1058 fprintf (stderr
, "Could not set desired port controls!\n");
1059 AIOGetExternalStatus (AIOhandle
, &extStatus
, &chgdExtStatus
);
1060 fprintf (stderr
, "Port controls now: %d, %d\n", extStatus
,
1064 /* Register ourselves as an alternate debugger. */
1065 memset (&s
, 0, sizeof s
);
1066 s
.DDSResourceTag
= ((struct ResourceTagStructure
*)
1067 AllocateResourceTag (GetNLMHandle (),
1068 (BYTE
*)"gdbserver",
1069 DebuggerSignature
));
1070 if (s
.DDSResourceTag
== 0)
1072 fprintf (stderr
, "AllocateResourceTag failed\n");
1073 AIOReleasePort (AIOhandle
);
1076 s
.DDSdebuggerEntry
= handle_exception
;
1077 s
.DDSFlags
= TSS_FRAME_BIT
;
1079 err
= RegisterDebuggerRTag (&s
, AT_FIRST
);
1082 fprintf (stderr
, "RegisterDebuggerRTag failed\n");
1083 AIOReleasePort (AIOhandle
);
1087 /* Get the command line we were invoked with, and advance it past
1088 our name and command line arguments. */
1089 cmdlin
= getcmd ((char *) NULL
);
1090 for (i
= 0; i
< cmdindx
; i
++)
1092 while (! isspace (*cmdlin
))
1094 while (isspace (*cmdlin
))
1098 /* In case GDB is started before us, ack any packets (presumably
1099 "$?#xx") sitting there. */
1100 if (! putDebugChar ('+'))
1102 fprintf (stderr
, "putDebugChar failed\n");
1103 UnRegisterDebugger (&s
);
1104 AIOReleasePort (AIOhandle
);
1108 mainthread
= GetThreadID ();
1110 if (remote_debug
> 0)
1111 ConsolePrintf ("About to call LoadModule with \"%s\" %08x\r\n",
1112 cmdlin
, __GetScreenID (GetCurrentScreen()));
1114 /* Start up the module to be debugged. */
1115 err
= LoadModule ((struct ScreenStruct
*) __GetScreenID (GetCurrentScreen()),
1116 (BYTE
*)cmdlin
, LO_DEBUG
);
1119 fprintf (stderr
, "LoadModule failed: %d\n", err
);
1120 UnRegisterDebugger (&s
);
1121 AIOReleasePort (AIOhandle
);
1125 /* Wait for the debugger to wake us up. */
1126 if (remote_debug
> 0)
1127 ConsolePrintf ("Suspending main thread (%08x)\r\n", mainthread
);
1128 SuspendThread (mainthread
);
1129 if (remote_debug
> 0)
1130 ConsolePrintf ("Resuming main thread (%08x)\r\n", mainthread
);
1132 /* If we are woken up, print an optional error message, deregister
1133 ourselves and exit. */
1134 if (error_message
!= NULL
)
1135 fprintf (stderr
, "%s\n", error_message
);
1136 UnRegisterDebugger (&s
);
1137 AIOReleasePort (AIOhandle
);