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