projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Testcase for: "ax-gdb: Do not treat enums and bools as integers".
[deliverable/binutils-gdb.git] / gdb / darwin-nat-info.c
CommitLineData
a80b95ba 1/* Darwin support for GDB, the GNU debugger.
0b302171 2 Copyright 1997-2002, 2008-2012 Free Software Foundation, Inc.
a80b95ba
TG		 3
4 Contributed by Apple Computer, Inc.
5
6 This file is part of GDB.
7
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
dcf7800b 10 the Free Software Foundation; either version 3 of the License, or
a80b95ba
TG		 11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
dcf7800b 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
a80b95ba
TG		 20
21/* The name of the ppc_thread_state structure, and the names of its
22 members, have been changed for Unix conformance reasons. The easiest
23 way to have gdb build on systems with the older names and systems
24 with the newer names is to build this compilation unit with the
25 non-conformant define below. This doesn't seem to cause the resulting
26 binary any problems but it seems like it could cause us problems in
27 the future. It'd be good to remove this at some point when compiling on
28 Tiger is no longer important. */
29
30#include "defs.h"
31#include "symtab.h"
32#include "gdbtypes.h"
33#include "gdbcore.h"
34#include "value.h"
35#include "gdbcmd.h"
36#include "inferior.h"
37
38#include <sys/param.h>
39#include <sys/sysctl.h>
40
41#include "darwin-nat.h"
42
43#include <mach/thread_info.h>
44#include <mach/thread_act.h>
45#include <mach/task.h>
46#include <mach/vm_map.h>
47#include <mach/mach_port.h>
48#include <mach/mach_init.h>
49#include <mach/mach_vm.h>
50
51#define CHECK_ARGS(what, args) do { \
52 if ((NULL == args) || ((args[0] != '0') && (args[1] != 'x'))) \
7ea6d463 53 error(_("%s must be specified with 0x..."), what); \
a80b95ba
TG		 54} while (0)
55
56#define PRINT_FIELD(structure, field) \
57 printf_unfiltered(_(#field":\t%#lx\n"), (unsigned long) (structure)->field)
58
59#define PRINT_TV_FIELD(structure, field) \
60 printf_unfiltered(_(#field":\t%u.%06u sec\n"), \
61 (unsigned) (structure)->field.seconds, \
62 (unsigned) (structure)->field.microseconds)
63
64#define task_self mach_task_self
65#define task_by_unix_pid task_for_pid
66#define port_name_array_t mach_port_array_t
67#define port_type_array_t mach_port_array_t
68
69static void
70info_mach_tasks_command (char *args, int from_tty)
71{
72 int sysControl[4];
73 int count, index;
74 size_t length;
75 struct kinfo_proc *procInfo;
76
77 sysControl[0] = CTL_KERN;
78 sysControl[1] = KERN_PROC;
79 sysControl[2] = KERN_PROC_ALL;
80
81 sysctl (sysControl, 3, NULL, &length, NULL, 0);
82 procInfo = (struct kinfo_proc *) xmalloc (length);
83 sysctl (sysControl, 3, procInfo, &length, NULL, 0);
84
85 count = (length / sizeof (struct kinfo_proc));
86 printf_unfiltered (_("%d processes:\n"), count);
87 for (index = 0; index < count; ++index)
88 {
89 kern_return_t result;
90 mach_port_t taskPort;
91
92 result =
93 task_by_unix_pid (mach_task_self (), procInfo[index].kp_proc.p_pid,
94 &taskPort);
95 if (KERN_SUCCESS == result)
96 {
97 printf_unfiltered (_(" %s is %d has task %#x\n"),
98 procInfo[index].kp_proc.p_comm,
99 procInfo[index].kp_proc.p_pid, taskPort);
100 }
101 else
102 {
103 printf_unfiltered (_(" %s is %d unknown task port\n"),
104 procInfo[index].kp_proc.p_comm,
105 procInfo[index].kp_proc.p_pid);
106 }
107 }
108
109 xfree (procInfo);
110}
111
112static task_t
113get_task_from_args (char *args)
114{
115 task_t task;
116 char *eptr;
117
118 if (args == NULL || *args == 0)
119 {
bb00b29d 120 if (ptid_equal (inferior_ptid, null_ptid))
a80b95ba 121 printf_unfiltered (_("No inferior running\n"));
bb00b29d 122 return current_inferior ()->private->task;
a80b95ba
TG		 123 }
124 if (strcmp (args, "gdb") == 0)
125 return mach_task_self ();
126 task = strtoul (args, &eptr, 0);
127 if (*eptr)
128 {
129 printf_unfiltered (_("cannot parse task id '%s'\n"), args);
130 return TASK_NULL;
131 }
132 return task;
133}
134
135static void
136info_mach_task_command (char *args, int from_tty)
137{
138 union
139 {
140 struct task_basic_info basic;
141 struct task_events_info events;
142 struct task_thread_times_info thread_times;
143 } task_info_data;
144
145 kern_return_t result;
146 unsigned int info_count;
147 task_t task;
148
149 task = get_task_from_args (args);
150 if (task == TASK_NULL)
151 return;
152
153 printf_unfiltered (_("TASK_BASIC_INFO for 0x%x:\n"), task);
154 info_count = TASK_BASIC_INFO_COUNT;
155 result = task_info (task,
156 TASK_BASIC_INFO,
157 (task_info_t) & task_info_data.basic, &info_count);
158 MACH_CHECK_ERROR (result);
159
160 PRINT_FIELD (&task_info_data.basic, suspend_count);
161 PRINT_FIELD (&task_info_data.basic, virtual_size);
162 PRINT_FIELD (&task_info_data.basic, resident_size);
163 PRINT_TV_FIELD (&task_info_data.basic, user_time);
164 PRINT_TV_FIELD (&task_info_data.basic, system_time);
165 printf_unfiltered (_("\nTASK_EVENTS_INFO:\n"));
166 info_count = TASK_EVENTS_INFO_COUNT;
167 result = task_info (task,
168 TASK_EVENTS_INFO,
169 (task_info_t) & task_info_data.events, &info_count);
170 MACH_CHECK_ERROR (result);
171
172 PRINT_FIELD (&task_info_data.events, faults);
173#if 0
174 PRINT_FIELD (&task_info_data.events, zero_fills);
175 PRINT_FIELD (&task_info_data.events, reactivations);
176#endif
177 PRINT_FIELD (&task_info_data.events, pageins);
178 PRINT_FIELD (&task_info_data.events, cow_faults);
179 PRINT_FIELD (&task_info_data.events, messages_sent);
180 PRINT_FIELD (&task_info_data.events, messages_received);
181 printf_unfiltered (_("\nTASK_THREAD_TIMES_INFO:\n"));
182 info_count = TASK_THREAD_TIMES_INFO_COUNT;
183 result = task_info (task,
184 TASK_THREAD_TIMES_INFO,
185 (task_info_t) & task_info_data.thread_times,
186 &info_count);
187 MACH_CHECK_ERROR (result);
188 PRINT_TV_FIELD (&task_info_data.thread_times, user_time);
189 PRINT_TV_FIELD (&task_info_data.thread_times, system_time);
190}
191
192static void
193info_mach_ports_command (char *args, int from_tty)
194{
195 port_name_array_t names;
196 port_type_array_t types;
197 unsigned int name_count, type_count;
198 kern_return_t result;
199 int index;
200 task_t task;
201
202 task = get_task_from_args (args);
203 if (task == TASK_NULL)
204 return;
205
206 result = mach_port_names (task, &names, &name_count, &types, &type_count);
207 MACH_CHECK_ERROR (result);
208
209 gdb_assert (name_count == type_count);
210
211 printf_unfiltered (_("Ports for task 0x%x:\n"), task);
212 printf_unfiltered (_("port type\n"));
213 for (index = 0; index < name_count; ++index)
214 {
215 mach_port_t port = names[index];
216 unsigned int j;
217 struct type_descr
218 {
219 mach_port_type_t type;
220 const char *name;
221 mach_port_right_t right;
222 };
223 static struct type_descr descrs[] =
224 {
225 {MACH_PORT_TYPE_SEND, "send", MACH_PORT_RIGHT_SEND},
226 {MACH_PORT_TYPE_SEND_ONCE, "send-once", MACH_PORT_RIGHT_SEND_ONCE},
227 {MACH_PORT_TYPE_RECEIVE, "receive", MACH_PORT_RIGHT_RECEIVE},
228 {MACH_PORT_TYPE_PORT_SET, "port-set", MACH_PORT_RIGHT_PORT_SET},
229 {MACH_PORT_TYPE_DEAD_NAME, "dead", MACH_PORT_RIGHT_DEAD_NAME}
230 };
231
232 printf_unfiltered (_("%04x: %08x "), port, types[index]);
233 for (j = 0; j < sizeof(descrs) / sizeof(*descrs); j++)
234 if (types[index] & descrs[j].type)
235 {
236 mach_port_urefs_t ref;
237 kern_return_t ret;
238
239 printf_unfiltered (_(" %s("), descrs[j].name);
240 ret = mach_port_get_refs (task, port, descrs[j].right, &ref);
241 if (ret != KERN_SUCCESS)
242 printf_unfiltered (_("??"));
243 else
244 printf_unfiltered (_("%u"), ref);
245 printf_unfiltered (_(" refs)"));
246 }
247
248 if (task == task_self ())
249 {
250 if (port == task_self())
251 printf_unfiltered (_(" gdb-task"));
252 else if (port == darwin_host_self)
253 printf_unfiltered (_(" host-self"));
a80b95ba
TG		 254 else if (port == darwin_ex_port)
255 printf_unfiltered (_(" gdb-exception"));
256 else if (port == darwin_port_set)
257 printf_unfiltered (_(" gdb-port_set"));
bb00b29d 258 else if (!ptid_equal (inferior_ptid, null_ptid))
a80b95ba 259 {
bb00b29d
TG		 260 struct inferior *inf = current_inferior ();
261
262 if (port == inf->private->task)
263 printf_unfiltered (_(" inferior-task"));
264 else if (port == inf->private->notify_port)
265 printf_unfiltered (_(" inferior-notify"));
266 else
267 {
268 int k;
269 darwin_thread_t *t;
270
271 for (k = 0; k < inf->private->exception_info.count; k++)
272 if (port == inf->private->exception_info.ports[k])
273 {
274 printf_unfiltered (_(" inferior-excp-port"));
275 break;
276 }
277
278 if (inf->private->threads)
279 {
280 for (k = 0;
281 VEC_iterate(darwin_thread_t,
282 inf->private->threads, k, t);
283 k++)
284 if (port == t->gdb_port)
285 {
286 printf_unfiltered (_(" inferior-thread for 0x%x"),
287 inf->private->task);
288 break;
289 }
290 }
291 }
a80b95ba
TG		 292 }
293 }
294 printf_unfiltered (_("\n"));
295 }
296
297 vm_deallocate (task_self (), (vm_address_t) names,
298 (name_count * sizeof (mach_port_t)));
299 vm_deallocate (task_self (), (vm_address_t) types,
300 (type_count * sizeof (mach_port_type_t)));
301}
302
303
304void
305darwin_debug_port_info (task_t task, mach_port_t port)
306{
307 kern_return_t kret;
308 mach_port_status_t status;
309 mach_msg_type_number_t len = sizeof (status);
310
311 kret = mach_port_get_attributes
312 (task, port, MACH_PORT_RECEIVE_STATUS, (mach_port_info_t)&status, &len);
313 MACH_CHECK_ERROR (kret);
314
315 printf_unfiltered (_("Port 0x%lx in task 0x%lx:\n"), (unsigned long) port,
316 (unsigned long) task);
317 printf_unfiltered (_(" port set: 0x%x\n"), status.mps_pset);
318 printf_unfiltered (_(" seqno: 0x%x\n"), status.mps_seqno);
319 printf_unfiltered (_(" mscount: 0x%x\n"), status.mps_mscount);
320 printf_unfiltered (_(" qlimit: 0x%x\n"), status.mps_qlimit);
321 printf_unfiltered (_(" msgcount: 0x%x\n"), status.mps_msgcount);
322 printf_unfiltered (_(" sorights: 0x%x\n"), status.mps_sorights);
323 printf_unfiltered (_(" srights: 0x%x\n"), status.mps_srights);
324 printf_unfiltered (_(" pdrequest: 0x%x\n"), status.mps_pdrequest);
325 printf_unfiltered (_(" nsrequest: 0x%x\n"), status.mps_nsrequest);
326 printf_unfiltered (_(" flags: 0x%x\n"), status.mps_flags);
327}
328
329static void
330info_mach_port_command (char *args, int from_tty)
331{
332 task_t task;
333 mach_port_t port;
334
335 CHECK_ARGS (_("Task and port"), args);
336 sscanf (args, "0x%x 0x%x", &task, &port);
337
338 darwin_debug_port_info (task, port);
339}
340
341static void
342info_mach_threads_command (char *args, int from_tty)
343{
344 thread_array_t threads;
345 unsigned int thread_count;
346 kern_return_t result;
347 task_t task;
348 int i;
349
350 task = get_task_from_args (args);
351 if (task == TASK_NULL)
352 return;
353
354 result = task_threads (task, &threads, &thread_count);
355 MACH_CHECK_ERROR (result);
356
357 printf_unfiltered (_("Threads in task %#x:\n"), task);
358 for (i = 0; i < thread_count; ++i)
359 {
360 printf_unfiltered (_(" %#x\n"), threads[i]);
361 mach_port_deallocate (task_self (), threads[i]);
362 }
363
364 vm_deallocate (task_self (), (vm_address_t) threads,
365 (thread_count * sizeof (thread_t)));
366}
367
368static void
369info_mach_thread_command (char *args, int from_tty)
370{
371 union
372 {
373 struct thread_basic_info basic;
374 } thread_info_data;
375
376 thread_t thread;
377 kern_return_t result;
378 unsigned int info_count;
379
380 CHECK_ARGS (_("Thread"), args);
381 sscanf (args, "0x%x", &thread);
382
383 printf_unfiltered (_("THREAD_BASIC_INFO\n"));
384 info_count = THREAD_BASIC_INFO_COUNT;
385 result = thread_info (thread,
386 THREAD_BASIC_INFO,
387 (thread_info_t) & thread_info_data.basic,
388 &info_count);
389 MACH_CHECK_ERROR (result);
390
391#if 0
392 PRINT_FIELD (&thread_info_data.basic, user_time);
393 PRINT_FIELD (&thread_info_data.basic, system_time);
394#endif
395 PRINT_FIELD (&thread_info_data.basic, cpu_usage);
396 PRINT_FIELD (&thread_info_data.basic, run_state);
397 PRINT_FIELD (&thread_info_data.basic, flags);
398 PRINT_FIELD (&thread_info_data.basic, suspend_count);
399 PRINT_FIELD (&thread_info_data.basic, sleep_time);
400}
401
402static const char *
403unparse_protection (vm_prot_t p)
404{
405 switch (p)
406 {
407 case VM_PROT_NONE:
408 return "---";
409 case VM_PROT_READ:
410 return "r--";
411 case VM_PROT_WRITE:
412 return "-w-";
413 case VM_PROT_READ | VM_PROT_WRITE:
414 return "rw-";
415 case VM_PROT_EXECUTE:
416 return "--x";
417 case VM_PROT_EXECUTE | VM_PROT_READ:
418 return "r-x";
419 case VM_PROT_EXECUTE | VM_PROT_WRITE:
420 return "-wx";
421 case VM_PROT_EXECUTE | VM_PROT_WRITE | VM_PROT_READ:
422 return "rwx";
423 default:
424 return "???";
425 }
426}
427
428static const char *
429unparse_inheritance (vm_inherit_t i)
430{
431 switch (i)
432 {
433 case VM_INHERIT_SHARE:
434 return _("share");
435 case VM_INHERIT_COPY:
436 return _("copy ");
437 case VM_INHERIT_NONE:
438 return _("none ");
439 default:
440 return _("??? ");
441 }
442}
443
444static const char *
445unparse_share_mode (unsigned char p)
446{
447 switch (p)
448 {
449 case SM_COW:
450 return _("cow");
451 case SM_PRIVATE:
452 return _("private");
453 case SM_EMPTY:
454 return _("empty");
455 case SM_SHARED:
456 return _("shared");
457 case SM_TRUESHARED:
458 return _("true-shrd");
459 case SM_PRIVATE_ALIASED:
460 return _("prv-alias");
461 case SM_SHARED_ALIASED:
462 return _("shr-alias");
463 default:
464 return _("???");
465 }
466}
467
468static const char *
469unparse_user_tag (unsigned int tag)
470{
471 switch (tag)
472 {
473 case 0:
474 return _("default");
475 case VM_MEMORY_MALLOC:
476 return _("malloc");
477 case VM_MEMORY_MALLOC_SMALL:
478 return _("malloc_small");
479 case VM_MEMORY_MALLOC_LARGE:
480 return _("malloc_large");
481 case VM_MEMORY_MALLOC_HUGE:
482 return _("malloc_huge");
483 case VM_MEMORY_SBRK:
484 return _("sbrk");
485 case VM_MEMORY_REALLOC:
486 return _("realloc");
487 case VM_MEMORY_MALLOC_TINY:
488 return _("malloc_tiny");
489 case VM_MEMORY_ANALYSIS_TOOL:
490 return _("analysis_tool");
491 case VM_MEMORY_MACH_MSG:
492 return _("mach_msg");
493 case VM_MEMORY_IOKIT:
494 return _("iokit");
495 case VM_MEMORY_STACK:
496 return _("stack");
497 case VM_MEMORY_GUARD:
498 return _("guard");
499 case VM_MEMORY_SHARED_PMAP:
500 return _("shared_pmap");
501 case VM_MEMORY_DYLIB:
502 return _("dylib");
503 case VM_MEMORY_APPKIT:
504 return _("appkit");
505 case VM_MEMORY_FOUNDATION:
506 return _("foundation");
507 default:
508 return NULL;
509 }
510}
511
512static void
513darwin_debug_regions (task_t task, mach_vm_address_t address, int max)
514{
515 kern_return_t kret;
516 vm_region_basic_info_data_64_t info, prev_info;
517 mach_vm_address_t prev_address;
518 mach_vm_size_t size, prev_size;
519
520 mach_port_t object_name;
521 mach_msg_type_number_t count;
522
523 int nsubregions = 0;
524 int num_printed = 0;
525
526 count = VM_REGION_BASIC_INFO_COUNT_64;
527 kret = mach_vm_region (task, &address, &size, VM_REGION_BASIC_INFO_64,
528 (vm_region_info_t) &info, &count, &object_name);
529 if (kret != KERN_SUCCESS)
530 {
531 printf_filtered (_("No memory regions."));
532 return;
533 }
534 memcpy (&prev_info, &info, sizeof (vm_region_basic_info_data_64_t));
535 prev_address = address;
536 prev_size = size;
537 nsubregions = 1;
538
539 for (;;)
540 {
541 int print = 0;
542 int done = 0;
543
544 address = prev_address + prev_size;
545
0963b4bd 546 /* Check to see if address space has wrapped around. */
a80b95ba
TG		 547 if (address == 0)
548 print = done = 1;
549
550 if (!done)
551 {
552 count = VM_REGION_BASIC_INFO_COUNT_64;
553 kret =
554 mach_vm_region (task, &address, &size, VM_REGION_BASIC_INFO_64,
555 (vm_region_info_t) &info, &count, &object_name);
556 if (kret != KERN_SUCCESS)
557 {
558 size = 0;
559 print = done = 1;
560 }
561 }
562
563 if (address != prev_address + prev_size)
564 print = 1;
565
566 if ((info.protection != prev_info.protection)
567 || (info.max_protection != prev_info.max_protection)
568 || (info.inheritance != prev_info.inheritance)
569 || (info.shared != prev_info.reserved)
570 || (info.reserved != prev_info.reserved))
571 print = 1;
572
573 if (print)
574 {
575 printf_filtered (_("%s-%s %s/%s %s %s %s"),
5af949e3
UW		 576 paddress (target_gdbarch, prev_address),
577 paddress (target_gdbarch, prev_address + prev_size),
a80b95ba
TG		 578 unparse_protection (prev_info.protection),
579 unparse_protection (prev_info.max_protection),
580 unparse_inheritance (prev_info.inheritance),
581 prev_info.shared ? _("shrd") : _("priv"),
582 prev_info.reserved ? _("reserved") : _("not-rsvd"));
583
584 if (nsubregions > 1)
585 printf_filtered (_(" (%d sub-rgn)"), nsubregions);
586
587 printf_filtered (_("\n"));
588
589 prev_address = address;
590 prev_size = size;
591 memcpy (&prev_info, &info, sizeof (vm_region_basic_info_data_64_t));
592 nsubregions = 1;
593
594 num_printed++;
595 }
596 else
597 {
598 prev_size += size;
599 nsubregions++;
600 }
601
602 if ((max > 0) && (num_printed >= max))
603 done = 1;
604
605 if (done)
606 break;
607 }
608}
609
610static void
611darwin_debug_regions_recurse (task_t task)
612{
613 mach_vm_address_t r_addr;
614 mach_vm_address_t r_start;
615 mach_vm_size_t r_size;
616 natural_t r_depth;
617 mach_msg_type_number_t r_info_size;
618 vm_region_submap_short_info_data_64_t r_info;
619 kern_return_t kret;
620 int ret;
bb00b29d 621 struct cleanup *table_chain;
6e2f5b22 622 struct ui_out *uiout = current_uiout;
bb00b29d
TG		 623
624 table_chain = make_cleanup_ui_out_table_begin_end (uiout, 9, -1, "regions");
625
b08f1e8d 626 if (gdbarch_addr_bit (target_gdbarch) <= 32)
bb00b29d
TG		 627 {
628 ui_out_table_header (uiout, 10, ui_left, "start", "Start");
629 ui_out_table_header (uiout, 10, ui_left, "end", "End");
630 }
631 else
632 {
633 ui_out_table_header (uiout, 18, ui_left, "start", "Start");
634 ui_out_table_header (uiout, 18, ui_left, "end", "End");
635 }
636 ui_out_table_header (uiout, 3, ui_left, "min-prot", "Min");
637 ui_out_table_header (uiout, 3, ui_left, "max-prot", "Max");
638 ui_out_table_header (uiout, 5, ui_left, "inheritence", "Inh");
639 ui_out_table_header (uiout, 9, ui_left, "share-mode", "Shr");
640 ui_out_table_header (uiout, 1, ui_left, "depth", "D");
641 ui_out_table_header (uiout, 3, ui_left, "submap", "Sm");
642 ui_out_table_header (uiout, 0, ui_noalign, "tag", "Tag");
643
644 ui_out_table_body (uiout);
a80b95ba
TG		 645
646 r_start = 0;
647 r_depth = 0;
648 while (1)
649 {
650 const char *tag;
bb00b29d 651 struct cleanup *row_chain;
a80b95ba
TG		 652
653 r_info_size = VM_REGION_SUBMAP_SHORT_INFO_COUNT_64;
654 r_size = -1;
655 kret = mach_vm_region_recurse (task, &r_start, &r_size, &r_depth,
656 (vm_region_recurse_info_t) &r_info,
657 &r_info_size);
658 if (kret != KERN_SUCCESS)
659 break;
bb00b29d
TG		 660 row_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "regions-row");
661
5af949e3
UW		 662 ui_out_field_core_addr (uiout, "start", target_gdbarch, r_start);
663 ui_out_field_core_addr (uiout, "end", target_gdbarch, r_start + r_size);
bb00b29d
TG		 664 ui_out_field_string (uiout, "min-prot",
665 unparse_protection (r_info.protection));
666 ui_out_field_string (uiout, "max-prot",
667 unparse_protection (r_info.max_protection));
668 ui_out_field_string (uiout, "inheritence",
669 unparse_inheritance (r_info.inheritance));
670 ui_out_field_string (uiout, "share-mode",
671 unparse_share_mode (r_info.share_mode));
672 ui_out_field_int (uiout, "depth", r_depth);
673 ui_out_field_string (uiout, "submap",
674 r_info.is_submap ? _("sm ") : _("obj"));
a80b95ba
TG		 675 tag = unparse_user_tag (r_info.user_tag);
676 if (tag)
bb00b29d 677 ui_out_field_string (uiout, "tag", tag);
a80b95ba 678 else
bb00b29d
TG		 679 ui_out_field_int (uiout, "tag", r_info.user_tag);
680
681 do_cleanups (row_chain);
682
683 if (!ui_out_is_mi_like_p (uiout))
684 ui_out_text (uiout, "\n");
685
a80b95ba
TG		 686 if (r_info.is_submap)
687 r_depth++;
688 else
689 r_start += r_size;
690 }
bb00b29d
TG		 691 do_cleanups (table_chain);
692
a80b95ba
TG		 693}
694
695
696static void
697darwin_debug_region (task_t task, mach_vm_address_t address)
698{
699 darwin_debug_regions (task, address, 1);
700}
701
702static void
703info_mach_regions_command (char *args, int from_tty)
704{
705 task_t task;
706
707 task = get_task_from_args (args);
708 if (task == TASK_NULL)
709 return;
710
711 darwin_debug_regions (task, 0, -1);
712}
713
714static void
715info_mach_regions_recurse_command (char *args, int from_tty)
716{
717 task_t task;
718
719 task = get_task_from_args (args);
720 if (task == TASK_NULL)
721 return;
722
723 darwin_debug_regions_recurse (task);
724}
725
726static void
727info_mach_region_command (char *exp, int from_tty)
728{
729 struct expression *expr;
730 struct value *val;
731 mach_vm_address_t address;
bb00b29d 732 struct inferior *inf;
a80b95ba
TG		 733
734 expr = parse_expression (exp);
735 val = evaluate_expression (expr);
736 if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
737 {
738 val = value_ind (val);
739 }
bb00b29d 740 address = value_as_address (val);
a80b95ba 741
bb00b29d 742 if (ptid_equal (inferior_ptid, null_ptid))
a80b95ba
TG		 743 error (_("Inferior not available"));
744
bb00b29d
TG		 745 inf = current_inferior ();
746 darwin_debug_region (inf->private->task, address);
a80b95ba
TG		 747}
748
749static void
750disp_exception (const darwin_exception_info *info)
751{
752 int i;
753
754 printf_filtered (_("%d exceptions:\n"), info->count);
755 for (i = 0; i < info->count; i++)
756 {
757 exception_mask_t mask = info->masks[i];
758
759 printf_filtered (_("port 0x%04x, behavior: "), info->ports[i]);
760 switch (info->behaviors[i])
761 {
762 case EXCEPTION_DEFAULT:
763 printf_unfiltered (_("default"));
764 break;
765 case EXCEPTION_STATE:
766 printf_unfiltered (_("state"));
767 break;
768 case EXCEPTION_STATE_IDENTITY:
769 printf_unfiltered (_("state-identity"));
770 break;
771 default:
772 printf_unfiltered (_("0x%x"), info->behaviors[i]);
773 }
774 printf_unfiltered (_(", masks:"));
775 if (mask & EXC_MASK_BAD_ACCESS)
776 printf_unfiltered (_(" BAD_ACCESS"));
777 if (mask & EXC_MASK_BAD_INSTRUCTION)
778 printf_unfiltered (_(" BAD_INSTRUCTION"));
779 if (mask & EXC_MASK_ARITHMETIC)
780 printf_unfiltered (_(" ARITHMETIC"));
781 if (mask & EXC_MASK_EMULATION)
782 printf_unfiltered (_(" EMULATION"));
783 if (mask & EXC_MASK_SOFTWARE)
784 printf_unfiltered (_(" SOFTWARE"));
785 if (mask & EXC_MASK_BREAKPOINT)
786 printf_unfiltered (_(" BREAKPOINT"));
787 if (mask & EXC_MASK_SYSCALL)
788 printf_unfiltered (_(" SYSCALL"));
789 if (mask & EXC_MASK_MACH_SYSCALL)
790 printf_unfiltered (_(" MACH_SYSCALL"));
791 if (mask & EXC_MASK_RPC_ALERT)
792 printf_unfiltered (_(" RPC_ALERT"));
793 if (mask & EXC_MASK_CRASH)
794 printf_unfiltered (_(" CRASH"));
795 printf_unfiltered (_("\n"));
796 }
797}
798
799static void
800info_mach_exceptions_command (char *args, int from_tty)
801{
802 int i;
803 task_t task;
804 kern_return_t kret;
805 darwin_exception_info info;
806
807 info.count = sizeof (info.ports) / sizeof (info.ports[0]);
808
809 if (args != NULL)
810 {
811 if (strcmp (args, "saved") == 0)
812 {
bb00b29d
TG		 813 if (ptid_equal (inferior_ptid, null_ptid))
814 printf_unfiltered (_("No inferior running\n"));
815 disp_exception (&current_inferior ()->private->exception_info);
a80b95ba
TG		 816 return;
817 }
818 else if (strcmp (args, "host") == 0)
819 {
766062f6 820 /* FIXME: This need a privilegied host port! */
a80b95ba
TG		 821 kret = host_get_exception_ports
822 (darwin_host_self, EXC_MASK_ALL, info.masks,
823 &info.count, info.ports, info.behaviors, info.flavors);
824 MACH_CHECK_ERROR (kret);
825 disp_exception (&info);
826 }
827 else
828 error (_("Parameter is saved, host or none"));
829 }
830 else
831 {
bb00b29d
TG		 832 struct inferior *inf;
833
834 if (ptid_equal (inferior_ptid, null_ptid))
835 printf_unfiltered (_("No inferior running\n"));
836 inf = current_inferior ();
a80b95ba
TG		 837
838 kret = task_get_exception_ports
bb00b29d 839 (inf->private->task, EXC_MASK_ALL, info.masks,
a80b95ba
TG		 840 &info.count, info.ports, info.behaviors, info.flavors);
841 MACH_CHECK_ERROR (kret);
842 disp_exception (&info);
843 }
844}
845
a80b95ba
TG		 846void
847_initialize_darwin_info_commands (void)
848{
849 add_info ("mach-tasks", info_mach_tasks_command,
850 _("Get list of tasks in system."));
851 add_info ("mach-ports", info_mach_ports_command,
852 _("Get list of ports in a task."));
853 add_info ("mach-port", info_mach_port_command,
854 _("Get info on a specific port."));
855 add_info ("mach-task", info_mach_task_command,
856 _("Get info on a specific task."));
857 add_info ("mach-threads", info_mach_threads_command,
858 _("Get list of threads in a task."));
859 add_info ("mach-thread", info_mach_thread_command,
860 _("Get info on a specific thread."));
861
862 add_info ("mach-regions", info_mach_regions_command,
863 _("Get information on all mach region for the task."));
864 add_info ("mach-regions-rec", info_mach_regions_recurse_command,
865 _("Get information on all mach sub region for the task."));
866 add_info ("mach-region", info_mach_region_command,
867 _("Get information on mach region at given address."));
868
869 add_info ("mach-exceptions", info_mach_exceptions_command,
870 _("Disp mach exceptions."));
871}
GDB Binutils - Deliverables
This page took 0.285487 seconds and 4 git commands to generate.