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