Commit | Line | Data |
---|---|---|
f823634c SG |
1 | /* Energize (formerly known as Cadillac) interface routines. |
2 | Copyright 1991, 1992 Free Software Foundation, Inc. | |
3 | ||
4 | This file is part of GDB. | |
5 | ||
6 | This program is free software; you can redistribute it and/or modify | |
7 | it under the terms of the GNU General Public License as published by | |
8 | the Free Software Foundation; either version 2 of the License, or | |
9 | (at your option) any later version. | |
10 | ||
11 | This program is distributed in the hope that it will be useful, | |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | GNU General Public License for more details. | |
15 | ||
16 | You should have received a copy of the GNU General Public License | |
17 | along with this program; if not, write to the Free Software | |
18 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ | |
19 | ||
20 | #include "defs.h" | |
21 | #include "symtab.h" | |
22 | #include "inferior.h" | |
23 | #include "command.h" | |
24 | #include "bfd.h" | |
25 | #include "symfile.h" | |
26 | #include "objfiles.h" | |
27 | #include <sys/types.h> | |
28 | #include <sys/time.h> | |
29 | #include <sys/param.h> | |
509c1804 SG |
30 | #include "energize/connection.h" |
31 | #include "energize/genericreq.h" | |
32 | #include "energize/debuggerreq.h" | |
33 | #include "energize/debuggerconn.h" | |
34 | #include "energize/ttyconn.h" | |
f823634c SG |
35 | #include <varargs.h> |
36 | #include <sys/stat.h> | |
37 | #ifdef USG | |
38 | #include <sys/file.h> | |
39 | #endif | |
40 | #include <fcntl.h> | |
41 | #include <sys/filio.h> | |
42 | #include <setjmp.h> | |
43 | #include <signal.h> | |
44 | #include <sys/errno.h> | |
45 | #include <termios.h> | |
46 | #include <string.h> | |
47 | ||
48 | /* Non-zero means that we're doing the energize interface. */ | |
49 | int energize = 0; | |
50 | ||
51 | /* Connection block for debugger<=>kernel communications. */ | |
52 | static Connection *conn = 0; | |
53 | ||
54 | /* fd for our socket to the kernel. */ | |
55 | static int kerfd; | |
56 | ||
57 | /* The kernel's ID for this instance of the program. */ | |
58 | static int program_id; | |
59 | ||
60 | static int instance_id; | |
61 | ||
62 | /* The fd for the pty associated with the inferior. */ | |
63 | static int inferior_pty = -1; | |
64 | static int inferior_tty = -1; | |
65 | ||
66 | static int has_run = 0; | |
67 | ||
68 | extern int pgrp_inferior; | |
69 | ||
70 | extern char *source_path; | |
71 | ||
b5fee91e SG |
72 | /* The name of the executable file */ |
73 | static char *exec_file; | |
f823634c SG |
74 | |
75 | /* Tell energize_command_line_input() where to get its text from */ | |
76 | static int doing_breakcommands_message = 0; | |
77 | ||
78 | /* Stash command text here */ | |
79 | static char *command_line_text = 0; | |
80 | static int command_line_length = 0; | |
81 | ||
82 | /* Flags returned by wait_for_events() */ | |
83 | #define KERNEL_EVENT 1 | |
84 | #define PTY_EVENT 2 | |
85 | ||
86 | \f | |
87 | /* This routine redirects the output of fputs_filtered to the kernel so that | |
88 | the user can see what's going on in his debugger window. */ | |
89 | ||
90 | void | |
91 | energize_fputs(ptr) | |
92 | const char *ptr; | |
93 | { | |
94 | if (conn) | |
95 | CVWriteTranscriptInfo (conn, instance_id, (char *)ptr); | |
96 | else | |
97 | fputs (ptr, stdout); | |
98 | } | |
99 | ||
100 | void | |
101 | energize_query(query, args) | |
102 | char *query; | |
103 | va_list args; | |
104 | { | |
105 | char buf[100]; | |
106 | ||
107 | if (!energize) | |
108 | return; | |
109 | ||
110 | vsprintf(buf, query, args); | |
111 | ||
112 | CVWriteQueryInfo(conn, | |
113 | instance_id, | |
114 | CQueryConfirm, | |
115 | qno_unknown, | |
116 | buf, | |
117 | ""); /* transcript */ | |
118 | } | |
119 | ||
120 | void | |
121 | energize_acknowledge_query(ack) | |
122 | char *ack; | |
123 | { | |
124 | CVWriteQueryInfo(conn, | |
125 | instance_id, | |
126 | CQueryAcknowleged, | |
127 | 0, | |
128 | ack, | |
129 | ""); /* transcript */ | |
130 | } | |
131 | ||
132 | /* Copy all data from the pty to the kernel. */ | |
133 | ||
134 | static void | |
135 | pty_to_kernel() | |
136 | { | |
137 | CTtyRequest *req; | |
138 | char buf[1024]; | |
139 | int cc; | |
140 | ||
141 | while (1) | |
142 | { | |
143 | cc = read(inferior_pty, buf, sizeof(buf)); | |
144 | ||
145 | if (cc == 0 | |
146 | || (cc < 0 | |
147 | && errno == EWOULDBLOCK)) | |
148 | break; | |
149 | ||
150 | if (cc < 0) | |
151 | { | |
152 | close(inferior_pty); | |
153 | inferior_pty = -1; | |
154 | perror("pty read error"); | |
155 | break; | |
156 | } | |
157 | ||
158 | req = CWriteTtyRequest(conn, TextIORType); | |
159 | CWriteVstringLen(conn, buf, cc); | |
160 | CWriteLength(conn); | |
161 | } | |
162 | CWriteRequestBuffer(conn); | |
163 | } | |
164 | ||
165 | /* Copy data from the kernel to the pty. */ | |
166 | ||
167 | static void | |
168 | kernel_to_pty(data, len) | |
169 | char *data; | |
170 | int len; | |
171 | { | |
172 | int cc; | |
173 | ||
174 | cc = write(inferior_pty, data, len); | |
175 | ||
176 | if (cc != len) | |
177 | { | |
178 | if (cc < 0) | |
179 | { | |
180 | close(inferior_pty); | |
181 | inferior_pty = -1; | |
182 | perror("pty write error"); | |
183 | return; | |
184 | } | |
185 | printf("Couldn't write all the data to the pty, wanted %d, got %d\n", | |
186 | len, cc); | |
187 | } | |
188 | } | |
189 | \f | |
190 | static char * | |
191 | full_filename(symtab) | |
192 | struct symtab *symtab; | |
193 | { | |
194 | int pathlen; | |
195 | char *filename; | |
196 | ||
197 | if (!symtab) | |
198 | return NULL; | |
199 | ||
200 | if (symtab->fullname) | |
201 | return savestring(symtab->fullname, strlen(symtab->fullname)); | |
202 | ||
203 | if (symtab->dirname) | |
204 | pathlen = strlen(symtab->dirname); | |
205 | else | |
206 | pathlen = 0; | |
207 | if (symtab->filename) | |
208 | pathlen += strlen(symtab->filename); | |
209 | ||
210 | filename = xmalloc(pathlen+1); | |
211 | ||
212 | if (symtab->dirname) | |
213 | strcpy(filename, symtab->dirname); | |
214 | else | |
215 | *filename = '\000'; | |
216 | if (symtab->filename) | |
217 | strcat(filename, symtab->filename); | |
218 | ||
219 | return filename; | |
220 | } | |
221 | ||
222 | /* Tell the energize kernel how high the stack is so that frame numbers (which | |
223 | are relative to the current stack height make sense. | |
224 | ||
225 | Calculate the number of frames on the stack, and the number of subroutine | |
226 | invocations that haven't changed since the last call to this routine. The | |
227 | second number is calculated by comparing the PCs of the current stack frames | |
228 | to the PCs of the previous set of stack frames. The screw here is that a | |
229 | subroutine may call several different procedures, which means that the PC | |
230 | in its frame changes, even though you are still in the same subroutine. We | |
231 | resolve this by converting the frames PC into the PC at the start of the | |
232 | function (for efficiency, this is done only if the simple comparison test | |
233 | fails). */ | |
234 | ||
235 | struct pclist | |
236 | { | |
237 | CORE_ADDR pc; | |
238 | struct pclist *next; | |
239 | }; | |
240 | ||
241 | /* Non-zero means that Energize kernel already knows how high the stack is. */ | |
242 | static int stack_info_valid = 0; | |
243 | ||
244 | static void | |
245 | send_stack_info() | |
246 | { | |
247 | struct pclist *pclist = 0, *pli, *opli; | |
248 | static struct pclist *old_pclist; | |
249 | FRAME frame; | |
250 | int height, similar; | |
251 | ||
252 | if (stack_info_valid) | |
253 | return; | |
254 | ||
255 | height = 0; | |
256 | similar = 0; | |
257 | ||
258 | /* First, calculate the stack height, and build the new pclist */ | |
259 | ||
260 | for (frame = get_current_frame(); | |
261 | frame != 0; | |
262 | frame = get_prev_frame(frame)) | |
263 | { | |
264 | (height)++; | |
265 | pli = (struct pclist *)xmalloc(sizeof(struct pclist)); | |
266 | ||
267 | pli->pc = frame->pc; | |
268 | pli->next = pclist; | |
269 | pclist = pli; | |
270 | } | |
271 | ||
272 | /* Now, figure out how much of the stack hasn't changed */ | |
273 | ||
274 | for (pli = pclist, opli = old_pclist; | |
275 | pli != 0 && opli != 0; | |
276 | pli = pli->next, opli = opli->next, (similar)++) | |
277 | { | |
278 | if ((pli->pc != opli->pc) | |
279 | && (get_pc_function_start(pli->pc) | |
280 | != get_pc_function_start(opli->pc))) | |
281 | break; | |
282 | } | |
283 | ||
284 | /* Free up all elements of the old pclist */ | |
285 | ||
286 | opli = old_pclist; | |
287 | ||
288 | while (opli) | |
289 | { | |
290 | pli = opli->next; | |
291 | free (opli); | |
292 | opli = pli; | |
293 | } | |
294 | ||
295 | old_pclist = pclist; /* Install the new pclist */ | |
296 | ||
297 | CVWriteStackSizeInfo(conn, | |
298 | instance_id, | |
299 | height, /* Frame depth */ | |
300 | CInnerFrameIs0, | |
301 | similar, /* Frame diff */ | |
302 | "" /* Transcript */ | |
303 | ); | |
304 | ||
305 | stack_info_valid = 1; | |
306 | } | |
307 | ||
308 | /* Tell the kernel where we are in the program, and what the stack looks like. | |
309 | */ | |
310 | ||
311 | static void | |
312 | send_status() | |
313 | { | |
314 | static int linecount = 48; | |
315 | struct symtab_and_line sal; | |
316 | struct symbol *symbol; | |
317 | char *funcname, *filename; | |
318 | static int sent_prog_inst = 0; | |
319 | ||
320 | if (!has_run) | |
321 | return; | |
322 | ||
323 | if (inferior_pid == 0) /* target has died */ | |
324 | { | |
325 | CVWriteProgramTerminatedInfo(conn, | |
326 | instance_id, | |
327 | "" | |
328 | ); | |
329 | return; | |
330 | } | |
331 | ||
332 | sal = find_pc_line(stop_pc, 0); | |
333 | symbol = find_pc_function(stop_pc); | |
334 | ||
335 | funcname = symbol ? symbol->name : ""; | |
336 | filename = full_filename(sal.symtab); | |
337 | ||
338 | if (!sent_prog_inst) | |
339 | { | |
340 | sent_prog_inst = 1; | |
341 | CVWriteProgramInstanceInfo(conn, | |
342 | program_id, | |
343 | instance_id, | |
344 | "", /* hostname */ | |
345 | "", /* arglist */ | |
346 | "" | |
347 | ); | |
348 | } | |
349 | ||
350 | send_stack_info(); | |
351 | ||
352 | CVWriteStackFrameInfo(conn, | |
353 | instance_id, | |
354 | sal.line, | |
355 | CFileLinePos, | |
356 | 0, /* XXX - frame # */ | |
357 | funcname, | |
358 | filename, | |
359 | "" /* XXX ? transcript */ | |
360 | ); | |
361 | ||
362 | CVWriteProgramStoppedInfo(conn, | |
363 | instance_id, | |
364 | 0, /* XXX - breakpoint # or signal # */ | |
365 | CDebuggerCommand, | |
366 | funcname, | |
367 | "" /* XXX ? transcript */ | |
368 | ); | |
369 | ||
370 | if (filename) | |
371 | free(filename); | |
372 | } | |
373 | ||
374 | /* Call this to output annotated function names. Names will be demangled if | |
375 | necessary. arg_mode contains flags that are passed on to cplus_demangle. */ | |
376 | ||
377 | void | |
378 | energize_annotate_function(funcname, arg_mode, level) | |
379 | char *funcname; | |
380 | int arg_mode; | |
381 | int level; | |
382 | { | |
383 | extern int demangle; | |
384 | char *demangled_name = NULL; | |
385 | ||
386 | if (funcname == NULL) | |
387 | return; | |
388 | ||
389 | if (demangle) | |
390 | { | |
391 | demangled_name = cplus_demangle(funcname, arg_mode); | |
392 | ||
393 | if (demangled_name) | |
394 | funcname = demangled_name; | |
395 | } | |
396 | ||
397 | send_stack_info(); | |
398 | ||
399 | if (level < 0) level = 0; | |
400 | ||
401 | CVWriteBackTraceEntryInfo(conn, | |
402 | instance_id, | |
403 | level, /* frameNo */ | |
404 | funcname); | |
405 | ||
406 | if (demangled_name) | |
407 | free(demangled_name); | |
408 | } | |
409 | ||
410 | /* Call this just prior to printing out the name & value of a variable. This | |
411 | tells the kernel where to annotate the output. */ | |
412 | ||
413 | /* The args are: | |
414 | expression - A text handle on what GDB can use to reference this value. | |
415 | This can be a symbol name, or a convenience var, etc... | |
416 | symbol - Used to determine the scope of the data. May be NULL. | |
417 | type - Determines if we have a pointer ref, and the print name of the type. | |
418 | Used in ShowValue message. | |
419 | valaddr - The address in target memory of the data. | |
420 | field - The field name of the struct or union element being referenced. | |
421 | */ | |
422 | ||
423 | static char cum_expr[200]; /* Cumulative expression */ | |
424 | static char *expr_stack[100] = {cum_expr}; /* Pointers to end of expressions */ | |
425 | static char **last_expr = expr_stack; /* Current expr stack pointer */ | |
426 | ||
427 | void | |
428 | energize_start_variable_annotation(expression, symbol, type, valaddr, field) | |
429 | char *expression; | |
430 | struct symbol *symbol; | |
431 | struct type *type; | |
432 | CORE_ADDR valaddr; | |
433 | char *field; | |
434 | { | |
435 | int ref_type; | |
436 | int stor_cl; | |
437 | enum type_code type_code; | |
438 | enum address_class sym_class; | |
439 | char *type_cast; | |
440 | ||
441 | if (!energize) | |
442 | return; | |
443 | ||
444 | send_stack_info(); | |
445 | ||
446 | strcpy(*last_expr++, expression); | |
447 | *last_expr = *(last_expr-1) + strlen(expression); | |
448 | ||
449 | switch (TYPE_CODE(type)) | |
450 | { | |
451 | case TYPE_CODE_ARRAY: | |
452 | case TYPE_CODE_STRUCT: | |
453 | case TYPE_CODE_UNION: | |
454 | case TYPE_CODE_ENUM: | |
455 | case TYPE_CODE_INT: | |
456 | case TYPE_CODE_FLT: | |
457 | ref_type = CValueValueRef; | |
458 | break; | |
459 | case TYPE_CODE_PTR: | |
460 | ref_type = CValuePointerRef; | |
461 | break; | |
462 | default: | |
463 | ref_type = CValueUndefRef; | |
464 | break; | |
465 | } | |
466 | ||
467 | /* Make sure that pointer points at something we understand */ | |
468 | ||
469 | if (ref_type == CValuePointerRef) | |
470 | switch (TYPE_CODE(TYPE_TARGET_TYPE(type))) | |
471 | { | |
472 | case TYPE_CODE_PTR: | |
473 | case TYPE_CODE_ARRAY: | |
474 | case TYPE_CODE_STRUCT: | |
475 | case TYPE_CODE_UNION: | |
476 | case TYPE_CODE_ENUM: | |
477 | case TYPE_CODE_INT: | |
478 | case TYPE_CODE_FLT: | |
479 | break; | |
480 | default: | |
481 | ref_type = CValueUndefRef; | |
482 | break; | |
483 | } | |
484 | ||
485 | if (symbol) | |
486 | { | |
487 | sym_class = SYMBOL_CLASS(symbol); | |
488 | ||
489 | switch (sym_class) | |
490 | { | |
491 | case LOC_CONST: | |
492 | case LOC_CONST_BYTES: | |
493 | stor_cl = CValueStorStaticConst; | |
494 | break; | |
495 | case LOC_STATIC: | |
496 | stor_cl = CValueStorStaticVar; | |
497 | break; | |
498 | case LOC_REGISTER: | |
499 | case LOC_REGPARM: | |
500 | stor_cl = CValueStorRegister; | |
501 | break; | |
502 | case LOC_ARG: | |
503 | case LOC_REF_ARG: | |
504 | case LOC_LOCAL: | |
505 | case LOC_LOCAL_ARG: | |
506 | stor_cl = CValueStorLocalVar; | |
507 | break; | |
508 | default: | |
509 | stor_cl = CValueStorUndef; | |
510 | break; | |
511 | } | |
512 | } | |
513 | else | |
514 | stor_cl = CValueStorUndef; | |
515 | ||
516 | type_cast = TYPE_NAME(type); | |
517 | ||
518 | CVWriteValueBeginInfo(conn, | |
519 | instance_id, | |
520 | valaddr, | |
521 | ref_type, | |
522 | stor_cl, | |
523 | 0, /* XXX - frameno */ | |
524 | cum_expr, | |
525 | field, | |
526 | type_cast, | |
527 | ""); /* transcript */ | |
528 | } | |
529 | ||
530 | void | |
531 | energize_end_variable_annotation() | |
532 | { | |
533 | if (!energize) | |
534 | return; | |
535 | ||
536 | last_expr--; /* Pop the expr stack */ | |
537 | **last_expr = '\000'; /* Cut off the last part of the expr */ | |
538 | ||
539 | CVWriteValueEndInfo(conn, | |
540 | instance_id, | |
541 | ""); /* transcript */ | |
542 | } | |
543 | \f | |
544 | /* Tell the kernel that the target is now running. */ | |
545 | ||
546 | static void | |
547 | go_busy() | |
548 | { | |
549 | CVWriteProgramBusyInfo(conn, | |
550 | instance_id, | |
551 | ""); /* XXX ? transcript */ | |
552 | CWriteRequestBuffer(conn); /* Must take place synchronusly! */ | |
553 | stack_info_valid = 0; | |
554 | } | |
555 | ||
556 | \f | |
557 | void | |
558 | energize_symbol_file(objfile) | |
559 | struct objfile *objfile; | |
560 | { | |
561 | if (!energize) | |
562 | return; | |
563 | ||
564 | CVWriteSymbolTableInfo(conn, | |
565 | objfile->name, | |
566 | ""); /* Transcript */ | |
567 | } | |
568 | ||
569 | /* execute_command_1(echo, queue, cmd, args) - echo - non-zero means echo the | |
570 | command. queue - non-zero means don't execute it now, just save it away for | |
571 | later. cmd - string containing printf control sequences. args - list of | |
572 | arguments needed by those control sequences. | |
573 | */ | |
574 | ||
575 | /* Linked list of queued up commands */ | |
576 | static struct command_line *queued_commands = 0; | |
577 | static struct command_line *last_queued_command = 0; | |
578 | ||
579 | /* Call this routine to save a command for later. The command string is | |
580 | copied into freshly malloc'ed memory. */ | |
581 | ||
582 | static void | |
583 | queue_command(cmd) | |
584 | char *cmd; | |
585 | { | |
586 | char *buf; | |
587 | struct command_line *cl; | |
588 | unsigned long s; | |
589 | ||
590 | s = (strlen(cmd) + 1) + 7 & ~(unsigned long)7; | |
591 | ||
592 | buf = (char *)xmalloc(s + sizeof(struct command_line)); | |
593 | cl = (struct command_line *)(buf + s); | |
594 | cl->next = 0; | |
595 | cl->line = buf; | |
596 | ||
597 | strncpy(cl->line, cmd, s); | |
598 | ||
599 | if (queued_commands) | |
600 | last_queued_command->next = cl; | |
601 | else | |
602 | queued_commands = cl; | |
603 | ||
604 | last_queued_command = cl; | |
605 | } | |
606 | ||
607 | /* Call this procedure to take a command off of the command queue. It returns | |
608 | a pointer to a buf which the caller is responsible for freeing. NULL is | |
609 | returned if there are no commands queued. */ | |
610 | ||
611 | static char * | |
612 | dequeue_command() | |
613 | { | |
614 | struct command_line *cl; | |
615 | char *cmd; | |
616 | ||
617 | cl = queued_commands; | |
618 | ||
619 | if (!cl) | |
620 | return NULL; | |
621 | ||
622 | queued_commands = cl->next; | |
623 | ||
624 | return cl->line; | |
625 | } | |
626 | ||
627 | static void | |
628 | execute_command_1(va_alist) | |
629 | va_dcl | |
630 | { | |
631 | char buf[100]; /* XXX - make buf dynamic! */ | |
632 | ||
633 | int echo; | |
634 | int queue; | |
635 | char *cmd; | |
636 | va_list args; | |
637 | ||
638 | va_start(args); | |
639 | ||
640 | echo = va_arg(args, int); | |
641 | queue = va_arg(args, int); | |
642 | cmd = va_arg(args, char *); | |
643 | ||
644 | vsprintf(buf, cmd, args); | |
645 | ||
646 | if (queue) | |
647 | queue_command(buf); | |
648 | else | |
649 | { | |
650 | if (echo) | |
651 | printf_filtered("%s\n", buf); | |
652 | execute_command(buf, 1); | |
653 | } | |
654 | ||
655 | va_end(args); | |
656 | } | |
657 | ||
658 | #ifdef KERNEL_RECORD | |
659 | FILE *kerout; | |
660 | ||
661 | static int | |
662 | kernel_record(fd, ptr, num) | |
663 | int fd, num; | |
664 | char *ptr; | |
665 | ||
666 | { | |
667 | fwrite(ptr, num, 1, kerout); | |
668 | fflush(kerout); | |
669 | return write(fd, ptr, num); | |
670 | } | |
671 | #endif | |
672 | ||
673 | void | |
674 | energize_condition_breakpoint(b) | |
675 | struct breakpoint *b; | |
676 | { | |
677 | if (energize) | |
678 | CVWriteBreakConditionInfo(conn, | |
679 | instance_id, | |
680 | b->number, | |
681 | b->cond_string ? b->cond_string : "", | |
682 | "" /* transcript */ | |
683 | ); | |
684 | } | |
685 | ||
686 | void | |
687 | energize_commands_breakpoint(b) | |
688 | struct breakpoint *b; | |
689 | { | |
690 | struct command_line *l; | |
691 | ||
692 | if (!energize) | |
693 | return; | |
694 | ||
695 | CVWriteBreakCommandBegInfo(conn, | |
696 | instance_id, | |
697 | b->number, | |
698 | ""); /* transcript */ | |
699 | ||
700 | for (l = b->commands; l; l = l->next) | |
701 | CVWriteBreakCommandEntryInfo(conn, | |
702 | instance_id, | |
703 | l->line, | |
704 | ""); /* transcript */ | |
705 | ||
706 | CVWriteBreakCommandEndInfo(conn, | |
707 | instance_id, | |
708 | ""); /* transcript */ | |
709 | } | |
710 | ||
711 | static void | |
712 | breakpoint_notify(b, action) | |
713 | struct breakpoint *b; | |
714 | int action; | |
715 | { | |
716 | struct symbol *sym; | |
717 | char *funcname = ""; | |
718 | char *filename; | |
719 | char *included_in_filename = ""; | |
720 | ||
721 | if (!energize) | |
722 | return; | |
723 | ||
724 | if (b->type != bp_breakpoint) | |
725 | return; | |
726 | ||
727 | filename = full_filename(b->symtab); | |
728 | ||
729 | sym = find_pc_function(b->address); | |
730 | if (sym) | |
731 | funcname = SYMBOL_NAME(sym); | |
732 | ||
733 | CVWriteBreakpointInfo (conn, | |
734 | instance_id, | |
735 | b->number, | |
736 | b->line_number, | |
737 | CFileLinePos, | |
738 | CBreakOnInstrAccess, | |
739 | action, | |
740 | b->ignore_count, | |
741 | funcname, | |
742 | filename ? filename : "", | |
743 | "", /* included_in_filename */ | |
744 | "" /* transcript */ | |
745 | ); | |
746 | ||
747 | if (b->commands) | |
748 | energize_commands_breakpoint(b); | |
749 | ||
750 | energize_condition_breakpoint(b); | |
751 | ||
752 | if (filename) | |
753 | free(filename); | |
754 | } | |
755 | ||
756 | void | |
757 | energize_create_breakpoint(b) | |
758 | struct breakpoint *b; | |
759 | { | |
760 | breakpoint_notify(b, CEnableBreakpoint); | |
761 | } | |
762 | ||
763 | void | |
764 | energize_delete_breakpoint(b) | |
765 | struct breakpoint *b; | |
766 | { | |
767 | breakpoint_notify(b, CDeleteBreakpoint); | |
768 | } | |
769 | ||
770 | void | |
771 | energize_enable_breakpoint(b) | |
772 | struct breakpoint *b; | |
773 | { | |
774 | breakpoint_notify(b, CEnableBreakpoint); | |
775 | } | |
776 | ||
777 | void | |
778 | energize_disable_breakpoint(b) | |
779 | struct breakpoint *b; | |
780 | { | |
781 | breakpoint_notify(b, CDisableBreakpoint); | |
782 | } | |
783 | ||
784 | void | |
785 | energize_ignore_breakpoint(b) | |
786 | struct breakpoint *b; | |
787 | { | |
788 | breakpoint_notify(b, CBreakAttrUnchanged); | |
789 | } | |
790 | \f | |
791 | /* Open up a pty and its associated tty. Return the fd of the tty. */ | |
792 | ||
793 | static void | |
794 | getpty() | |
795 | { | |
796 | int n, ptyfd, ttyfd; | |
797 | static char dev[30]; | |
798 | struct stat statbuf; | |
799 | struct termios termios; | |
800 | ||
801 | #define HIGHPTY (('z' - 'p') * 16 - 1) | |
802 | ||
803 | for (n = 0; n <= HIGHPTY; n++) | |
804 | { | |
805 | sprintf(dev, "/dev/pty%c%x", n/16 + 'p', n%16); | |
806 | if (stat(dev, &statbuf)) | |
807 | break; | |
808 | ptyfd = open(dev, O_RDWR); | |
809 | if (ptyfd < 0) | |
810 | continue; | |
811 | sprintf(dev, "/dev/tty%c%x", n/16 + 'p', n%16); | |
812 | ttyfd = open(dev, O_RDWR); | |
813 | if (ttyfd < 0) {close(ptyfd); continue;} | |
814 | ||
815 | /* Setup pty for non-blocking I/O. Also make it give us a SIGIO when | |
816 | there's data available. */ | |
817 | ||
818 | n = fcntl(ptyfd, F_GETFL, 0); | |
819 | fcntl(ptyfd, F_SETFL, n|FNDELAY|FASYNC); | |
820 | fcntl(ptyfd, F_SETOWN, getpid()); | |
821 | ||
822 | tcgetattr(ttyfd, &termios); | |
823 | termios.c_oflag &= ~OPOST; /* No post-processing */ | |
824 | tcsetattr(ttyfd, TCSANOW, &termios); | |
825 | ||
826 | inferior_pty = ptyfd; | |
827 | inferior_tty = ttyfd; | |
828 | return; | |
829 | } | |
830 | ||
831 | error ("getpty: can't get a pty\n"); | |
832 | } | |
833 | \f | |
834 | /* Examine a protocol packet from the driver. */ | |
835 | ||
836 | static void | |
837 | kernel_dispatch(queue) | |
838 | int queue; /* Non-zero means we should just queue up | |
839 | commands. */ | |
840 | { | |
841 | register CHeader *head; | |
842 | ||
843 | head = (CHeader *)CPeekNextRequest (conn); | |
844 | if (head == NULL) | |
845 | { | |
846 | fprintf (stderr, "EOF on kernel read!\n"); | |
847 | exit (1); | |
848 | } | |
849 | ||
850 | if (head->reqType < LastTtyRequestRType) | |
851 | { | |
852 | CTtyRequest* req = CReadTtyRequest (conn); | |
853 | switch (req->head.reqType) | |
854 | { | |
855 | case AcceptConnectionRType: | |
856 | /* Tell the rest of the world that energize is now set up */ | |
857 | CSkipRequest (conn); | |
858 | break; | |
859 | ||
860 | case RefuseConnectionRType: | |
861 | fprintf (stderr, "Debugger connection refused\n"); | |
862 | exit (1); | |
863 | ||
864 | case KillProgramRType: | |
865 | exit (0); | |
866 | ||
867 | case TextIORType: | |
868 | { | |
869 | char *p; | |
870 | ReqLen len; | |
871 | ||
872 | p = CGetVstring(conn, &len); | |
873 | kernel_to_pty(p, len); | |
874 | } | |
875 | break; | |
876 | default: | |
509c1804 | 877 | fprintf(stderr, "Unknown Tty request type = %d\n", |
f823634c SG |
878 | req->head.reqType); |
879 | break; | |
880 | } | |
881 | } | |
882 | else | |
883 | { | |
884 | CVDebuggerRequest *req = CVReadDebuggerRequest (conn); | |
885 | if (!req) | |
886 | { | |
887 | fprintf (stderr, "CVReadDebuggerRequest returned NULL, type = %d\n", | |
888 | head->reqType); | |
889 | exit(1); | |
890 | } | |
891 | ||
892 | switch (req->head.request->reqType) | |
893 | { | |
894 | case OpenProgramInstanceRType: | |
895 | { | |
896 | char *arglist, buf[100]; /* XXX - Make buf dynamic! */ | |
897 | int arglen; | |
898 | /* XXX - should notice when program_id changes */ | |
899 | arglist = req->openProgramInstance.progArglist.text; | |
900 | arglen = req->openProgramInstance.progArglist.byteLen; | |
901 | ||
902 | execute_command_1(1, queue, "break main"); | |
903 | execute_command_1(1, queue, "enable delete $bpnum"); | |
904 | if (arglist) | |
905 | { | |
906 | execute_command_1(1, queue, "set args %.*s", arglen, arglist); | |
907 | } | |
908 | execute_command_1(1, queue, "run"); | |
909 | } | |
910 | break; | |
911 | case SearchPathRType: | |
912 | directory_command(req->searchPath.searchPath.text, 0); | |
913 | break; | |
914 | case QuitDebuggerRType: | |
915 | execute_command_1(1, queue, "quit"); | |
916 | break; | |
917 | case RunRType: | |
918 | if (req->run.request->useArglist == CNewArglist) | |
919 | { | |
920 | execute_command_1(1, queue, "set args %.*s", | |
921 | req->run.progArglist.byteLen, | |
922 | req->run.progArglist.text); | |
923 | } | |
924 | execute_command_1(1, queue, "run"); | |
925 | break; | |
926 | case ContinueRType: | |
927 | execute_command_1(1, queue, "continue"); | |
928 | break; | |
929 | case StepRType: | |
930 | execute_command_1(1, queue, "step %d", req->step.request->stepCount); | |
931 | break; | |
932 | case NextRType: | |
933 | execute_command_1(1, queue, "next %d", req->next.request->nextCount); | |
934 | break; | |
935 | case ChangeStackFrameRType: | |
936 | switch (req->changeStackFrame.request->frameMovement) | |
937 | { | |
938 | case CToCurrentStackFrame: | |
939 | execute_command_1(1, queue, "frame %d", | |
940 | req->changeStackFrame.request->frameNo); | |
941 | break; | |
942 | case CToInnerStackFrame: | |
943 | execute_command_1(1, queue, "down %d", | |
944 | req->changeStackFrame.request->frameNo); | |
945 | break; | |
946 | case CToOuterStackFrame: | |
947 | execute_command_1(1, queue, "up %d", | |
948 | req->changeStackFrame.request->frameNo); | |
949 | break; | |
950 | case CToAbsoluteStackFrame: | |
951 | execute_command_1(1, queue, "frame %d", | |
952 | req->changeStackFrame.request->frameNo); | |
953 | break; | |
954 | } | |
955 | break; | |
956 | case BackTraceRType: | |
957 | /* XXX - deal with limit??? */ | |
958 | execute_command_1(1, queue, "backtrace"); | |
959 | break; | |
960 | case FinishRType: | |
961 | execute_command_1(1, queue, "finish"); | |
962 | break; | |
963 | case TerminateProgramRType: | |
964 | execute_command_1(1, queue, "kill"); | |
965 | break; | |
966 | case NewBreakpointRType: | |
967 | { | |
968 | char *tail; | |
969 | int skipped; | |
970 | ||
971 | tail = strrchr(req->newBreakpoint.fileName.text, '/'); | |
972 | if (!tail) | |
973 | tail = req->newBreakpoint.fileName.text; | |
974 | else | |
975 | tail++; | |
976 | skipped = tail - req->newBreakpoint.fileName.text; | |
977 | execute_command_1(1, queue, "break %.*s:%d", | |
978 | req->newBreakpoint.fileName.byteLen - skipped, | |
979 | tail, | |
980 | req->newBreakpoint.request->fileLinePos); | |
981 | } | |
982 | break; | |
983 | case StopRType: | |
984 | killpg(pgrp_inferior, SIGINT); | |
985 | break; | |
986 | case UserInputRType: | |
987 | { | |
988 | char *text; | |
989 | long len; | |
990 | ||
991 | /* XXX - should really break command up into seperate lines | |
992 | and spoon-feed it to execute_command */ | |
993 | ||
994 | text = req->userInput.userInput.text; | |
995 | len = req->userInput.userInput.byteLen; | |
996 | ||
997 | if (text[len-1] == '\n') text[len-1] = '\000'; | |
998 | ||
999 | while (*text == ' ' || *text == '\t') text++; | |
1000 | ||
1001 | if (strcmp(text, "]*[") == 0) /* XXX - What does this mean??? */ | |
1002 | break; | |
1003 | ||
1004 | if (*text != '\000') | |
1005 | execute_command_1(0, queue, "%s", text); | |
1006 | else | |
1007 | print_prompt(); /* User just typed a blank line */ | |
1008 | } | |
1009 | break; | |
1010 | case QueryResponseRType: | |
1011 | { | |
1012 | char *resp; | |
1013 | ||
1014 | if (req->queryResponse.request->response) | |
1015 | resp = "y"; | |
1016 | else | |
1017 | resp = "n"; | |
1018 | execute_command_1(1, 1, resp); | |
1019 | printf_filtered("%s\n", resp); | |
1020 | } | |
1021 | break; | |
1022 | case ChangeBreakpointRType: | |
1023 | switch (req->changeBreakpoint.request->breakpointAttr) | |
1024 | { | |
1025 | case CBreakAttrUnchanged: | |
1026 | execute_command_1(1, queue, "ignore %d %d", | |
1027 | req->changeBreakpoint.request->breakpointId, | |
1028 | req->changeBreakpoint.request->ignoreCount); | |
1029 | break; | |
1030 | case CEnableBreakpoint: | |
1031 | execute_command_1(1, queue, "enable %d", | |
1032 | req->changeBreakpoint.request->breakpointId); | |
1033 | break; | |
1034 | case CDisableBreakpoint: | |
1035 | execute_command_1(1, queue, "disable %d", | |
1036 | req->changeBreakpoint.request->breakpointId); | |
1037 | break; | |
1038 | case CDeleteBreakpoint: | |
1039 | execute_command_1(1, queue, "delete %d", | |
1040 | req->changeBreakpoint.request->breakpointId); | |
1041 | break; | |
1042 | case CEnableDisableBreakpoint: | |
1043 | execute_command_1(1, queue, "enable once %d", | |
1044 | req->changeBreakpoint.request->breakpointId); | |
1045 | break; | |
1046 | case CEnableDeleteBreakpoint: | |
1047 | execute_command_1(1, queue, "enable delete %d", | |
1048 | req->changeBreakpoint.request->breakpointId); | |
1049 | break; | |
1050 | default: | |
1051 | printf_filtered("ChangeBreakpointRType: unknown breakpointAttr\n"); | |
1052 | printf_filtered(" breakpointAttr = %d\n", | |
1053 | req->changeBreakpoint.request->breakpointAttr); | |
1054 | printf_filtered(" breakpointId = %d\n", | |
1055 | req->changeBreakpoint.request->breakpointId); | |
1056 | printf_filtered(" breakpointType = %d\n", | |
1057 | req->changeBreakpoint.request->breakpointType); | |
1058 | printf_filtered(" ignoreCount = %d\n", | |
1059 | req->changeBreakpoint.request->ignoreCount); | |
1060 | break; | |
1061 | } | |
1062 | break; | |
1063 | case BreakConditionRType: | |
1064 | execute_command_1(1, queue, "condition %d %.*s", | |
1065 | req->breakCondition.request->breakpointId, | |
1066 | req->breakCondition.condition.byteLen, | |
1067 | req->breakCondition.condition.text); | |
1068 | break; | |
1069 | case BreakCommandsRType: | |
1070 | /* Put pointers to where energize_command_line_input() can find | |
1071 | them. */ | |
1072 | doing_breakcommands_message = 1; | |
1073 | command_line_length = req->breakCommands.commands.byteLen; | |
1074 | command_line_text = req->breakCommands.commands.text; | |
1075 | execute_command_1(1, queue, "commands %d", | |
1076 | req->breakCommands.request->breakpointId); | |
1077 | command_line_text = (char *)NULL; | |
1078 | command_line_length = 0; | |
1079 | doing_breakcommands_message = 0; | |
1080 | break; | |
1081 | case ShowValueRType: | |
1082 | { | |
1083 | char expr[100], *p = expr; | |
1084 | ||
1085 | expr[0] = 0; | |
1086 | ||
1087 | if (req->showValue.request->ref_type == CValuePointerRef) | |
1088 | strcat(expr, "* "); | |
1089 | ||
1090 | if (req->showValue.type_cast.byteLen) | |
1091 | { | |
1092 | strcat(expr, "("); | |
1093 | strncat(expr, req->showValue.type_cast.text, | |
1094 | req->showValue.type_cast.byteLen); | |
1095 | strcat(expr, ") "); | |
1096 | } | |
1097 | ||
1098 | if (req->showValue.field.byteLen) | |
1099 | strcat(expr, "("); | |
1100 | ||
1101 | strncat(expr, req->showValue.expression.text, | |
1102 | req->showValue.expression.byteLen); | |
1103 | ||
1104 | if (req->showValue.field.byteLen) | |
1105 | { | |
1106 | strcat(expr, ")"); | |
1107 | ||
1108 | strncat(expr, req->showValue.field.text, | |
1109 | req->showValue.field.byteLen); | |
1110 | } | |
1111 | ||
1112 | execute_command_1(1, queue, "print %s", expr); | |
1113 | } | |
1114 | break; | |
1115 | case SetValueRType: | |
1116 | { | |
1117 | char expr[100], *p = expr; | |
1118 | ||
1119 | expr[0] = 0; | |
1120 | ||
1121 | if (req->setValue.request->ref_type == CValuePointerRef) | |
1122 | strcat(expr, "* "); | |
1123 | ||
1124 | #if 0 | |
1125 | if (req->setValue.type_cast.byteLen) | |
1126 | { | |
1127 | strcat(expr, "("); | |
1128 | strncat(expr, req->setValue.type_cast.text, | |
1129 | req->setValue.type_cast.byteLen); | |
1130 | strcat(expr, ") "); | |
1131 | } | |
1132 | #endif | |
1133 | if (req->setValue.field.byteLen) | |
1134 | strcat(expr, "("); | |
1135 | ||
1136 | strncat(expr, req->setValue.expression.text, | |
1137 | req->setValue.expression.byteLen); | |
1138 | ||
1139 | if (req->setValue.field.byteLen) | |
1140 | { | |
1141 | strcat(expr, ")"); | |
1142 | ||
1143 | strncat(expr, req->setValue.field.text, | |
1144 | req->setValue.field.byteLen); | |
1145 | } | |
1146 | ||
1147 | execute_command_1(1, queue, "print %s = (%s) %s", expr, | |
1148 | req->setValue.type_cast.text, | |
1149 | req->setValue.value.text); | |
1150 | } | |
1151 | break; | |
509c1804 | 1152 | case DynamicLoadRType: |
b5fee91e SG |
1153 | { |
1154 | char *filename; | |
1155 | ||
1156 | filename = req->dynamicLoad.filenames.byteLen ? | |
1157 | req->dynamicLoad.filenames.text : exec_file; | |
1158 | ||
1159 | switch (req->dynamicLoad.request->action) | |
1160 | { | |
1161 | case CDynamicLoadUpdateSymtab: | |
1162 | execute_command_1(1, queue, "exec-file %s", filename); | |
1163 | execute_command_1(1, queue, "symbol-file %s", filename); | |
1164 | break; | |
1165 | default: | |
1166 | printf_filtered("DynamicLoadRType: unknown action=%d, filename=%s\n", | |
1167 | req->dynamicLoad.request->action, | |
1168 | req->dynamicLoad.filenames.text); | |
1169 | break; | |
1170 | } | |
1171 | } | |
509c1804 | 1172 | break; |
f823634c | 1173 | default: |
509c1804 | 1174 | fprintf(stderr, "Unknown Debugger request type = %d\n", |
f823634c SG |
1175 | req->head.request->reqType); |
1176 | break; | |
1177 | } | |
1178 | free (req); /* Should probably call CVFreeDebuggerRequest() here, but | |
1179 | can't do so if interrupt level has mucked with req-> | |
1180 | request. CVFreeDebuggerRequest() only ends up calling | |
1181 | free() anyway! */ | |
1182 | } | |
1183 | } | |
1184 | \f | |
1185 | /* Return a bitmask indicating if the kernel or the pty did something | |
1186 | interesting. Set poll to non-zero if you don't want to wait. */ | |
1187 | ||
1188 | static int | |
1189 | wait_for_events(poll) | |
1190 | int poll; | |
1191 | { | |
1192 | fd_set readfds; | |
1193 | int numfds; | |
1194 | int eventmask = 0; | |
1195 | static struct timeval tv = {0}; | |
1196 | ||
1197 | /* Output all pending requests. */ | |
1198 | CWriteRequestBuffer(conn); | |
1199 | ||
1200 | FD_ZERO(&readfds); | |
1201 | ||
1202 | /* Wait till there's some activity from the kernel or the pty. */ | |
1203 | do | |
1204 | { | |
1205 | FD_SET(kerfd, &readfds); | |
1206 | if (inferior_pty > 0) | |
1207 | FD_SET(inferior_pty, &readfds); | |
1208 | if (poll) | |
1209 | numfds = select(sizeof(readfds)*8, &readfds, 0, 0, &tv); | |
1210 | else | |
1211 | numfds = select(sizeof(readfds)*8, &readfds, 0, 0, 0); | |
1212 | } | |
1213 | while (numfds <= 0 && !poll); | |
1214 | ||
1215 | if (FD_ISSET(inferior_pty, &readfds)) | |
1216 | eventmask |= PTY_EVENT; | |
1217 | ||
1218 | if (FD_ISSET(kerfd, &readfds)) | |
1219 | eventmask |= KERNEL_EVENT; | |
1220 | ||
1221 | return eventmask; | |
1222 | } | |
1223 | \f | |
1224 | /* This is called from read_command_lines() to provide the text for breakpoint | |
1225 | commands, which is supplied in a BreakCommands message. Each call to this | |
1226 | routine supplies a single line of text, with the newline removed. */ | |
1227 | ||
1228 | /* This routine may be invoked in two different contexts. In the first, it | |
1229 | is being called as a result of the BreakCommands message. In this case, | |
1230 | all of the command text is immediately available. In the second case, it is | |
1231 | called as a result of the user typing the 'command' command. The command | |
1232 | text then needs to be glommed out of UserInput messages (and possibly other | |
1233 | messages as well). The most 'straighforward' way of doing this is to | |
1234 | basically simulate the main loop, but just accumulate the command text | |
1235 | instead of sending it to execute_command(). */ | |
1236 | ||
1237 | char * | |
1238 | energize_command_line_input(prompt, repeat) | |
1239 | char *prompt; | |
1240 | int repeat; | |
1241 | { | |
1242 | char *p; | |
1243 | ||
1244 | if (!energize) | |
1245 | return command_line_input(prompt, repeat); | |
1246 | ||
1247 | if (doing_breakcommands_message) | |
1248 | { | |
1249 | if (command_line_length <= 0) | |
1250 | return (char *)NULL; | |
1251 | ||
1252 | p = command_line_text; | |
1253 | ||
1254 | while (command_line_length-- > 0) | |
1255 | { | |
1256 | if (*command_line_text == '\n') | |
1257 | { | |
1258 | *command_line_text = '\000'; | |
1259 | command_line_text++; | |
1260 | break; | |
1261 | } | |
1262 | command_line_text++; | |
1263 | } | |
1264 | ||
1265 | printf_filtered("%s\n", p); | |
1266 | return p; | |
1267 | } | |
1268 | else | |
1269 | { | |
1270 | /* We come here when the user has typed the 'command' or 'define' command | |
1271 | to the GDB window. We are basically deep inside of the 'command' | |
1272 | command processing routine right now, and will be called to get a new | |
1273 | line of input. We expect that kernel_dispatch will queue up only one | |
1274 | command at a time. */ | |
1275 | ||
1276 | int eventmask; | |
1277 | static char buf[100]; | |
1278 | ||
1279 | eventmask = wait_for_events(0); | |
1280 | ||
1281 | if (eventmask & PTY_EVENT) | |
1282 | pty_to_kernel(); | |
1283 | ||
1284 | if (eventmask & KERNEL_EVENT) | |
1285 | kernel_dispatch(1); /* Queue up commands */ | |
1286 | ||
1287 | /* Note that command has been echoed by the time we get here */ | |
1288 | ||
1289 | p = dequeue_command(); | |
1290 | ||
1291 | if (p) | |
1292 | { | |
1293 | strncpy(buf, p, sizeof(buf)); | |
1294 | free(p); | |
1295 | return buf; | |
1296 | } | |
1297 | else | |
1298 | return NULL; | |
1299 | } | |
1300 | } | |
1301 | \f | |
1302 | /* Establish contact with the kernel. */ | |
1303 | ||
1304 | void | |
1305 | energize_initialize(energize_id, execarg) | |
1306 | char *energize_id; | |
1307 | char *execarg; | |
1308 | { | |
1309 | CTtyRequest *req; | |
1310 | char *ctmp; | |
1311 | extern long strtol(char *str, char **ptr, int base); | |
1312 | char pathname[MAXPATHLEN]; | |
1313 | int n; | |
1314 | ||
1315 | if (!energize_id) | |
1316 | return; | |
1317 | ||
1318 | if (!execarg) execarg = ""; | |
1319 | ||
b5fee91e SG |
1320 | exec_file = strdup(execarg); /* Save for later */ |
1321 | ||
f823634c SG |
1322 | printf("\ngdb-debugger pid=%d\n", getpid()); /* XXX - debugging only */ |
1323 | ||
1324 | /* First establish the connection with the kernel. */ | |
1325 | ||
1326 | kerfd = COpenClientSocket(NULL); | |
1327 | if (kerfd < 0) { | |
1328 | printf("COpenClientSocket() failed\n"); | |
1329 | exit(1); | |
1330 | } | |
1331 | ||
1332 | /* Setup for I/O interrupts when appropriate. */ | |
1333 | ||
1334 | n = fcntl(kerfd, F_GETFL, 0); | |
1335 | fcntl(kerfd, F_SETFL, n|FASYNC); | |
1336 | fcntl(kerfd, F_SETOWN, getpid()); | |
1337 | ||
1338 | /* Setup connection buffering. */ | |
1339 | ||
1340 | CSetSocketBufferSize (kerfd, 12000); | |
1341 | ||
1342 | /* Generate a new connection control block. */ | |
1343 | ||
1344 | conn = NewConnection (0, kerfd, kerfd); | |
1345 | if (!conn) { | |
1346 | printf("NewConnection() failed\n"); | |
1347 | exit(1); | |
1348 | } | |
1349 | ||
1350 | #ifdef KERNEL_RECORD | |
1351 | kerout = fopen("kernel.output", "+w"); | |
1352 | ||
1353 | CReadWriteHooks(conn, conn->previewMethod, conn->readMethod, kernel_record); | |
1354 | #endif | |
1355 | ||
1356 | /* Tell the kernel that we are the "debugger". */ | |
1357 | ||
1358 | req = CWriteTtyRequest (conn, QueryConnectionRType); | |
1359 | req->generic.queryconnection.major = 0; | |
1360 | req->generic.queryconnection.minor = 0; | |
1361 | req->generic.queryconnection.cadillacId1=strtol(energize_id, &ctmp, 16); | |
1362 | req->generic.queryconnection.cadillacId2 = strtol(++ctmp, NULL, 16); | |
1363 | req->generic.queryconnection.nProtocols = 1; | |
1364 | CWriteProtocol (conn, 0, 0, "debugger"); | |
1365 | CWriteLength (conn); | |
1366 | ||
1367 | /* Tell the kernel that we are actually running. */ | |
1368 | ||
1369 | /* KROCK ALERT!!! The kernel doesn't really care about the arguments to | |
1370 | the program at all! It only cares that argument 7 be the name of the | |
1371 | target program. So, we just fill in the rest of the slots with | |
1372 | padding. I hope the kernel never cares about this! */ | |
1373 | ||
1374 | req = CWriteTtyRequest (conn, RunningProgramRType); | |
1375 | req->runningprogram.argc = 8; | |
1376 | getwd (pathname); | |
1377 | CWriteVstring0 (conn, pathname); | |
1378 | ||
1379 | CWriteVstring0 (conn, "0"); | |
1380 | CWriteVstring0 (conn, "1"); | |
1381 | CWriteVstring0 (conn, "2"); | |
1382 | CWriteVstring0 (conn, "3"); | |
1383 | CWriteVstring0 (conn, "4"); | |
1384 | CWriteVstring0 (conn, "5"); | |
1385 | CWriteVstring0 (conn, "6"); | |
1386 | CWriteVstring0 (conn, execarg); | |
1387 | CWriteLength (conn); | |
1388 | ||
1389 | /* Tell the kernel our PID and all that */ | |
1390 | ||
1391 | program_id = 1; | |
1392 | CVWriteDebugProgramInfo(conn, | |
1393 | getpid(), | |
1394 | program_id, | |
1395 | execarg, | |
1396 | ""); | |
1397 | ||
1398 | /* Tell the rest of the world that Energize is now set up. */ | |
1399 | energize = 1; | |
1400 | ||
1401 | setsid(); /* Drop controlling tty, become pgrp master */ | |
1402 | getpty(); /* Setup the pty */ | |
1403 | dup2(inferior_tty, 0); /* Attach all GDB I/O to the pty */ | |
1404 | dup2(inferior_tty, 1); | |
1405 | dup2(inferior_tty, 2); | |
1406 | } | |
1407 | ||
1408 | /* This is called from execute_command, and provides a wrapper around | |
1409 | various command routines in a place where both protocol messages and | |
1410 | user input both flow through. | |
1411 | */ | |
1412 | ||
1413 | void | |
1414 | energize_call_command(cmdblk, arg, from_tty) | |
1415 | struct cmd_list_element *cmdblk; | |
1416 | char *arg; | |
1417 | int from_tty; | |
1418 | { | |
1419 | if (!energize) | |
1420 | { | |
1421 | (*cmdblk->function.cfunc) (arg, from_tty); | |
1422 | return; | |
1423 | } | |
1424 | ||
1425 | if (cmdblk->class == class_run) | |
1426 | { | |
1427 | go_busy(); | |
1428 | has_run = 1; | |
1429 | (*cmdblk->function.cfunc)(arg, from_tty); | |
1430 | send_status(); | |
1431 | } | |
1432 | else | |
1433 | (*cmdblk->function.cfunc)(arg, from_tty); | |
1434 | ||
1435 | print_prompt(); | |
1436 | } | |
1437 | ||
1438 | void | |
1439 | energize_new_process() | |
1440 | { | |
1441 | instance_id = inferior_pid; | |
1442 | } | |
1443 | ||
1444 | static void | |
1445 | iosig(signo) | |
1446 | int signo; | |
1447 | { | |
1448 | while (1) | |
1449 | { | |
1450 | int eventmask; | |
1451 | ||
1452 | eventmask = wait_for_events(1); | |
1453 | ||
1454 | if (eventmask == 0) | |
1455 | return; | |
1456 | ||
1457 | if (eventmask & PTY_EVENT) | |
1458 | pty_to_kernel(); | |
1459 | ||
1460 | if (eventmask & KERNEL_EVENT) | |
1461 | kernel_dispatch(1); | |
1462 | } | |
1463 | } | |
1464 | ||
1465 | int | |
1466 | energize_wait(status) | |
1467 | int *status; | |
1468 | { | |
1469 | int pid; | |
1470 | ||
1471 | if (!energize) | |
1472 | return wait(status); | |
1473 | ||
1474 | signal(SIGIO, iosig); | |
1475 | ||
1476 | pid = wait(status); | |
1477 | ||
1478 | signal(SIGIO, SIG_DFL); | |
1479 | return pid; | |
1480 | } | |
1481 | ||
1482 | static void | |
1483 | null_routine(arg) | |
1484 | int arg; | |
1485 | { | |
1486 | } | |
1487 | ||
1488 | /* All requests from the Energize kernel eventually end up here. */ | |
1489 | ||
1490 | void | |
1491 | energize_main_loop() | |
1492 | { | |
1493 | CTtyRequest *req; | |
1494 | struct cleanup *old_chain; | |
1495 | ||
1496 | doing_breakcommands_message = 0; | |
1497 | ||
1498 | /* We will come thru here any time there is an error, so send status if | |
1499 | necessary. */ | |
1500 | ||
1501 | send_status(); | |
1502 | ||
1503 | print_prompt(); | |
1504 | ||
1505 | /* The actual event loop! */ | |
1506 | ||
1507 | while (1) | |
1508 | { | |
1509 | int eventmask; | |
1510 | char *cmd; | |
1511 | ||
1512 | old_chain = make_cleanup(null_routine, 0); | |
1513 | ||
1514 | /* First, empty out the command queue, then check for new requests. */ | |
1515 | ||
1516 | while (cmd = dequeue_command()) | |
1517 | { | |
1518 | execute_command_1(1, 0, cmd); | |
1519 | free(cmd); | |
1520 | } | |
1521 | ||
1522 | eventmask = wait_for_events(0); | |
1523 | ||
1524 | if (eventmask & PTY_EVENT) | |
1525 | pty_to_kernel(); | |
1526 | ||
1527 | if (eventmask & KERNEL_EVENT) | |
1528 | kernel_dispatch(0); | |
1529 | ||
1530 | bpstat_do_actions(&stop_bpstat); | |
1531 | do_cleanups(old_chain); | |
1532 | } | |
1533 | } |