1 /* Target-vector operations for controlling Mac applications, for GDB.
2 Copyright 1995, 1996, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Written by Stan Shebs. Contributed by Cygnus Support.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without eve nthe implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Note that because all the available Mac compilers are ANSI or very
24 close, and this is a native-only file, the code may be purely ANSI. */
27 #include "frame.h" /* required by inferior.h */
34 #include <sys/types.h>
37 #include "gdb_string.h"
38 #include "gdbthread.h"
42 #include <Processes.h>
44 /* We call the functions "child_..." rather than "mac_..." so no one
45 is tempted to try to link this with other native-only code. */
47 /* Forward declaration */
49 extern struct target_ops child_ops
;
51 static void child_stop (void);
54 child_fetch_inferior_registers (int r
)
58 for (r
= 0; r
< NUM_REGS
; r
++)
59 child_fetch_inferior_registers (r
);
63 supply_register (r
, 0);
68 child_store_inferior_registers (int r
)
72 for (r
= 0; r
< NUM_REGS
; r
++)
73 child_store_inferior_registers (r
);
77 read_register_gen (r
, 0);
82 child_wait (int pid
, struct target_waitstatus
*ourstatus
)
86 /* Attach to process PID, then initialize for debugging it. */
89 child_attach (char *args
, int from_tty
)
91 ProcessSerialNumber psn
;
92 ProcessInfoRec inforec
;
100 error_no_arg ("process-id to attach");
104 psn
.highLongOfPSN
= 0;
105 psn
.lowLongOfPSN
= pid
;
107 inforec
.processInfoLength
= sizeof (ProcessInfoRec
);
108 inforec
.processName
= name
;
109 inforec
.processAppSpec
= fsspec
;
111 if (GetProcessInformation (&psn
, &inforec
) == noErr
)
115 exec_file
= (char *) get_exec_file (0);
118 printf_unfiltered ("Attaching to program `%s', %s\n", exec_file
,
119 target_pid_to_str (pid
));
121 printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid
));
123 gdb_flush (gdb_stdout
);
125 /* Do we need to do anything special? */
128 push_target (&child_ops
);
133 child_detach (char *args
, int from_tty
)
139 exec_file
= get_exec_file (0);
142 printf_unfiltered ("Detaching from program: %s %s\n", exec_file
,
143 target_pid_to_str (inferior_pid
));
144 gdb_flush (gdb_stdout
);
147 unpush_target (&child_ops
);
150 /* Print status information about what we're accessing. */
153 child_files_info (struct target_ops
*ignore
)
155 printf_unfiltered ("\tUsing the running image of %s %s.\n",
156 attach_flag
? "attached" : "child", target_pid_to_str (inferior_pid
));
161 child_open (char *arg
, int from_tty
)
163 error ("Use the \"run\" command to start a Mac application.");
166 /* Start an inferior Mac program and sets inferior_pid to its pid.
167 EXEC_FILE is the file to run.
168 ALLARGS is a string containing the arguments to the program.
169 ENV is the environment vector to pass. Errors reported with error(). */
172 child_create_inferior (char *exec_file
, char *allargs
, char **env
)
174 LaunchParamBlockRec launchparms
;
180 error ("No executable specified, use `target exec'.\n");
183 launchparms
.launchBlockID
= extendedBlock
;
184 launchparms
.launchEPBLength
= extendedBlockLen
;
185 launchparms
.launchFileFlags
= 0;
186 launchparms
.launchControlFlags
= launchContinue
| launchNoFileFlags
;
189 strcpy (fsspec
.name
+ 1, exec_file
);
190 fsspec
.name
[0] = strlen (exec_file
);
191 launchparms
.launchAppSpec
= &fsspec
;
192 launchparms
.launchAppParameters
= nil
;
194 launch_err
= LaunchApplication (&launchparms
);
196 if (launch_err
== 999 /*memFullErr */ )
198 error ("Not enough memory to launch %s\n", exec_file
);
200 else if (launch_err
!= noErr
)
202 error ("Error launching %s, code %d\n", exec_file
, launch_err
);
205 inferior_pid
= launchparms
.launchProcessSN
.lowLongOfPSN
;
206 /* FIXME be sure that high long of PSN is 0 */
208 push_target (&child_ops
);
209 init_wait_for_inferior ();
210 clear_proceed_status ();
212 /* proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0); */
216 child_mourn_inferior (void)
218 unpush_target (&child_ops
);
219 generic_mourn_inferior ();
228 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
229 struct mem_attrib
*attrib
,
230 struct target_ops
*target
)
234 for (i
= 0; i
< len
; ++i
)
238 ((char *) memaddr
)[i
] = myaddr
[i
];
242 myaddr
[i
] = ((char *) memaddr
)[i
];
249 child_kill_inferior (void)
254 child_resume (int pid
, int step
, enum target_signal signal
)
259 child_prepare_to_store (void)
261 /* Do nothing, since we can store individual regs */
276 info_proc (char *args
, int from_tty
)
278 ProcessSerialNumber psn
;
279 ProcessInfoRec inforec
;
284 /* Eventually use args, but not right now. */
286 psn
.highLongOfPSN
= 0;
287 psn
.lowLongOfPSN
= kNoProcess
;
289 inforec
.processInfoLength
= sizeof (ProcessInfoRec
);
290 inforec
.processName
= name
;
291 inforec
.processAppSpec
= fsspec
;
293 printf_filtered ("Process Name Sgnt Type PSN Loc Size FreeMem Time\n");
295 while (GetNextProcess (&psn
) == noErr
)
297 if (GetProcessInformation (&psn
, &inforec
) == noErr
)
299 name
[name
[0] + 1] = '\0';
300 printf_filtered ("%-32.32s", name
+ 1);
301 code
= inforec
.processSignature
;
302 printf_filtered (" %c%c%c%c",
307 code
= inforec
.processType
;
308 printf_filtered (" %c%c%c%c",
313 if (psn
.highLongOfPSN
== 0)
314 printf_filtered (" %9d", psn
.lowLongOfPSN
);
316 printf_filtered (" %9d,%9d\n",
317 psn
.highLongOfPSN
, psn
.lowLongOfPSN
);
318 printf_filtered (" 0x%x", inforec
.processLocation
);
319 printf_filtered (" %9d", inforec
.processSize
);
320 printf_filtered (" %9d", inforec
.processFreeMem
);
321 printf_filtered (" %9d", inforec
.processActiveTime
);
322 printf_filtered ("\n");
327 struct target_ops child_ops
;
330 init_child_ops (void)
332 child_ops
.to_shortname
= "mac";
333 child_ops
.to_longname
= "MacOS application";
334 child_ops
.to_doc
= "MacOS application (started by the \"run\" command).";
335 child_ops
.to_open
= child_open
;
336 child_ops
.to_close
= child_close
;
337 child_ops
.to_attach
= child_attach
;
338 child_ops
.to_post_attach
= NULL
;
339 child_ops
.to_require_attach
= NULL
; /* to_require_attach */
340 child_ops
.to_detach
= child_detach
;
341 child_ops
.to_require_detach
= NULL
; /* to_require_detach */
342 child_ops
.to_resume
= child_resume
;
343 child_ops
.to_wait
= child_wait
;
344 child_ops
.to_post_wait
= NULL
; /* to_post_wait */
345 child_ops
.to_fetch_registers
= child_fetch_inferior_registers
;
346 child_ops
.to_store_registers
= child_store_inferior_registers
;
347 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
348 child_ops
.to_xfer_memory
= child_xfer_memory
;
349 child_ops
.to_files_info
= child_files_info
;
350 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
351 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
352 child_ops
.to_terminal_init
= 0;
353 child_ops
.to_terminal_inferior
= 0;
354 child_ops
.to_terminal_ours_for_output
= 0;
355 child_ops
.to_terminal_ours
= 0;
356 child_ops
.to_terminal_info
= 0;
357 child_ops
.to_kill
= child_kill_inferior
;
358 child_ops
.to_load
= 0;
359 child_ops
.to_lookup_symbol
= 0;
360 child_ops
.to_create_inferior
= child_create_inferior
;
361 child_ops
.to_post_startup_inferior
= NULL
; /* to_post_startup_inferior */
362 child_ops
.to_acknowledge_created_inferior
= NULL
; /* to_acknowledge_created_inferior */
363 child_ops
.to_clone_and_follow_inferior
= NULL
; /* to_clone_and_follow_inferior */
364 child_ops
.to_post_follow_inferior_by_clone
= NULL
; /* to_post_follow_inferior_by_clone */
365 child_ops
.to_insert_fork_catchpoint
= NULL
;
366 child_ops
.to_remove_fork_catchpoint
= NULL
;
367 child_ops
.to_insert_vfork_catchpoint
= NULL
;
368 child_ops
.to_remove_vfork_catchpoint
= NULL
;
369 child_ops
.to_has_forked
= NULL
; /* to_has_forked */
370 child_ops
.to_has_vforked
= NULL
; /* to_has_vforked */
371 child_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
372 child_ops
.to_post_follow_vfork
= NULL
; /* to_post_follow_vfork */
373 child_ops
.to_insert_exec_catchpoint
= NULL
;
374 child_ops
.to_remove_exec_catchpoint
= NULL
;
375 child_ops
.to_has_execd
= NULL
;
376 child_ops
.to_reported_exec_events_per_exec_call
= NULL
;
377 child_ops
.to_has_exited
= NULL
;
378 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
379 child_ops
.to_can_run
= child_can_run
;
380 child_ops
.to_notice_signals
= 0;
381 child_ops
.to_thread_alive
= 0;
382 child_ops
.to_stop
= child_stop
;
383 child_ops
.to_pid_to_exec_file
= NULL
; /* to_pid_to_exec_file */
384 child_ops
.to_stratum
= process_stratum
;
385 child_ops
.DONT_USE
= 0;
386 child_ops
.to_has_all_memory
= 1;
387 child_ops
.to_has_memory
= 1;
388 child_ops
.to_has_stack
= 1;
389 child_ops
.to_has_registers
= 1;
390 child_ops
.to_has_execution
= 1;
391 child_ops
.to_sections
= 0;
392 child_ops
.to_sections_end
= 0;
393 child_ops
.to_magic
= OPS_MAGIC
;
397 _initialize_mac_nat (void)
401 add_info ("proc", info_proc
,
402 "Show information about processes.");