1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2020 Free Software Foundation, Inc.
5 Contributed by Apple Computer, Inc.
6 Written by Michael Snyder.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
27 #include "parser-defs.h"
31 #include "objc-lang.h"
32 #include "complaints.h"
36 #include "target.h" /* for target_has_execution */
40 #include "gdb_regex.h"
45 #include "cli/cli-utils.h"
56 CORE_ADDR super_class
;
78 static const struct objfile_key
<unsigned int> objc_objfile_data
;
80 /* Lookup a structure type named "struct NAME", visible in lexical
81 block BLOCK. If NOERR is nonzero, return zero if NAME is not
85 lookup_struct_typedef (const char *name
, const struct block
*block
, int noerr
)
89 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
96 error (_("No struct type named %s."), name
);
98 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
103 error (_("This context has class, union or enum %s, not a struct."),
110 lookup_objc_class (struct gdbarch
*gdbarch
, const char *classname
)
112 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
113 struct value
* function
, *classval
;
115 if (! target_has_execution
)
117 /* Can't call into inferior to lookup class. */
121 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0).minsym
)
122 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
123 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym
)
124 function
= find_function_in_inferior("objc_lookup_class", NULL
);
127 complaint (_("no way to lookup Objective-C classes"));
131 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
132 classval
= value_coerce_array (classval
);
133 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
139 lookup_child_selector (struct gdbarch
*gdbarch
, const char *selname
)
141 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
142 struct value
* function
, *selstring
;
144 if (! target_has_execution
)
146 /* Can't call into inferior to lookup selector. */
150 if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym
)
151 function
= find_function_in_inferior("sel_getUid", NULL
);
152 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym
)
153 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
156 complaint (_("no way to lookup Objective-C selectors"));
160 selstring
= value_coerce_array (value_string (selname
,
161 strlen (selname
) + 1,
163 return value_as_long (call_function_by_hand (function
, NULL
, selstring
));
167 value_nsstring (struct gdbarch
*gdbarch
, char *ptr
, int len
)
169 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
170 struct value
*stringValue
[3];
171 struct value
*function
, *nsstringValue
;
175 if (!target_has_execution
)
176 return 0; /* Can't call into inferior to create NSString. */
178 stringValue
[2] = value_string(ptr
, len
, char_type
);
179 stringValue
[2] = value_coerce_array(stringValue
[2]);
180 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
181 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym
)
183 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
184 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
186 else if (lookup_minimal_symbol("istr", 0, 0).minsym
)
188 function
= find_function_in_inferior("istr", NULL
);
189 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
191 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym
)
194 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
195 type
= builtin_type (gdbarch
)->builtin_long
;
197 stringValue
[0] = value_from_longest
198 (type
, lookup_objc_class (gdbarch
, "NSString"));
199 stringValue
[1] = value_from_longest
200 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
201 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
);
204 error (_("NSString: internal error -- no way to create new NSString"));
206 sym
= lookup_struct_typedef("NSString", 0, 1);
208 sym
= lookup_struct_typedef("NXString", 0, 1);
210 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
212 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
214 deprecated_set_value_type (nsstringValue
, type
);
215 return nsstringValue
;
218 /* Objective-C name demangling. */
221 objc_demangle (const char *mangled
, int options
)
223 char *demangled
, *cp
;
225 if (mangled
[0] == '_' &&
226 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
229 cp
= demangled
= (char *) xmalloc (strlen (mangled
) + 2);
231 if (mangled
[1] == 'i')
232 *cp
++ = '-'; /* for instance method */
234 *cp
++ = '+'; /* for class method */
236 *cp
++ = '['; /* opening left brace */
237 strcpy(cp
, mangled
+3); /* Tack on the rest of the mangled name. */
239 while (*cp
&& *cp
== '_')
240 cp
++; /* Skip any initial underbars in class
243 cp
= strchr(cp
, '_');
244 if (!cp
) /* Find first non-initial underbar. */
246 xfree(demangled
); /* not mangled name */
249 if (cp
[1] == '_') /* Easy case: no category name. */
251 *cp
++ = ' '; /* Replace two '_' with one ' '. */
252 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
256 *cp
++ = '('; /* Less easy case: category name. */
257 cp
= strchr(cp
, '_');
260 xfree(demangled
); /* not mangled name */
264 *cp
++ = ' '; /* Overwriting 1st char of method name... */
265 strcpy(cp
, mangled
+ (cp
- demangled
)); /* Get it back. */
268 while (*cp
&& *cp
== '_')
269 cp
++; /* Skip any initial underbars in
274 *cp
= ':'; /* Replace remaining '_' with ':'. */
276 *cp
++ = ']'; /* closing right brace */
277 *cp
++ = 0; /* string terminator */
281 return NULL
; /* Not an objc mangled name. */
285 /* Table mapping opcodes into strings for printing operators
286 and precedences of the operators. */
288 static const struct op_print objc_op_print_tab
[] =
290 {",", BINOP_COMMA
, PREC_COMMA
, 0},
291 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
292 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
293 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
294 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
295 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
296 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
297 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
298 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
299 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
300 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
301 {">", BINOP_GTR
, PREC_ORDER
, 0},
302 {"<", BINOP_LESS
, PREC_ORDER
, 0},
303 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
304 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
305 {"+", BINOP_ADD
, PREC_ADD
, 0},
306 {"-", BINOP_SUB
, PREC_ADD
, 0},
307 {"*", BINOP_MUL
, PREC_MUL
, 0},
308 {"/", BINOP_DIV
, PREC_MUL
, 0},
309 {"%", BINOP_REM
, PREC_MUL
, 0},
310 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
311 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
312 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
313 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
314 {"*", UNOP_IND
, PREC_PREFIX
, 0},
315 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
316 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
317 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
318 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
319 {NULL
, OP_NULL
, PREC_NULL
, 0}
322 static const char *objc_extensions
[] =
327 /* Constant data representing the Objective-C language. */
329 extern const struct language_data objc_language_data
=
331 "objective-c", /* Language name */
339 &exp_descriptor_standard
,
342 c_printchar
, /* Print a character constant */
343 c_printstr
, /* Function to print string constant */
345 c_print_typedef
, /* Print a typedef using appropriate syntax */
346 "self", /* name_of_this */
347 false, /* la_store_sym_names_in_linkage_form_p */
348 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
349 objc_op_print_tab
, /* Expression operators for printing */
350 1, /* C-style arrays */
351 0, /* String lower bound */
354 "{...}" /* la_struct_too_deep_ellipsis */
357 /* Class representing the Objective-C language. */
359 class objc_language
: public language_defn
363 : language_defn (language_objc
, objc_language_data
)
366 /* See language.h. */
367 void language_arch_info (struct gdbarch
*gdbarch
,
368 struct language_arch_info
*lai
) const override
370 c_language_arch_info (gdbarch
, lai
);
373 /* See language.h. */
374 bool sniff_from_mangled_name (const char *mangled
,
375 char **demangled
) const override
377 *demangled
= objc_demangle (mangled
, 0);
378 return *demangled
!= NULL
;
381 /* See language.h. */
383 char *demangle (const char *mangled
, int options
) const override
385 return objc_demangle (mangled
, options
);
388 /* See language.h. */
390 void print_type (struct type
*type
, const char *varstring
,
391 struct ui_file
*stream
, int show
, int level
,
392 const struct type_print_options
*flags
) const override
394 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
397 /* See language.h. */
399 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
400 CORE_ADDR stop_pc
) const override
402 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
403 CORE_ADDR real_stop_pc
;
404 CORE_ADDR method_stop_pc
;
406 /* Determine if we are currently in the Objective-C dispatch function.
407 If so, get the address of the method function that the dispatcher
408 would call and use that as the function to step into instead. Also
409 skip over the trampoline for the function (if any). This is better
410 for the user since they are only interested in stepping into the
411 method function anyway. */
413 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
415 if (real_stop_pc
!= 0)
416 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
418 find_objc_msgcall (stop_pc
, &method_stop_pc
);
422 real_stop_pc
= gdbarch_skip_trampoline_code
423 (gdbarch
, frame
, method_stop_pc
);
424 if (real_stop_pc
== 0)
425 real_stop_pc
= method_stop_pc
;
432 /* Single instance of the class representing the Objective-C language. */
434 static objc_language objc_language_defn
;
438 * Following functions help construct Objective-C message calls.
441 struct selname
/* For parsing Objective-C. */
443 struct selname
*next
;
448 static int msglist_len
;
449 static struct selname
*selname_chain
;
450 static char *msglist_sel
;
455 struct selname
*newobj
= XNEW (struct selname
);
457 newobj
->next
= selname_chain
;
458 newobj
->msglist_len
= msglist_len
;
459 newobj
->msglist_sel
= msglist_sel
;
461 msglist_sel
= (char *)xmalloc(1);
463 selname_chain
= newobj
;
467 add_msglist(struct stoken
*str
, int addcolon
)
473 if (str
== 0) /* Unnamed arg, or... */
475 if (addcolon
== 0) /* variable number of args. */
488 len
= plen
+ strlen(msglist_sel
) + 2;
489 s
= (char *)xmalloc(len
);
490 strcpy(s
, msglist_sel
);
505 end_msglist (struct parser_state
*ps
)
507 int val
= msglist_len
;
508 struct selname
*sel
= selname_chain
;
509 char *p
= msglist_sel
;
512 selname_chain
= sel
->next
;
513 msglist_len
= sel
->msglist_len
;
514 msglist_sel
= sel
->msglist_sel
;
515 selid
= lookup_child_selector (ps
->gdbarch (), p
);
517 error (_("Can't find selector \"%s\""), p
);
518 write_exp_elt_longcst (ps
, selid
);
520 write_exp_elt_longcst (ps
, val
); /* Number of args */
527 * Function: specialcmp (const char *a, const char *b)
529 * Special strcmp: treats ']' and ' ' as end-of-string.
530 * Used for qsorting lists of objc methods (either by class or selector).
534 specialcmp (const char *a
, const char *b
)
536 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
542 if (*a
&& *a
!= ' ' && *a
!= ']')
543 return 1; /* a is longer therefore greater. */
544 if (*b
&& *b
!= ' ' && *b
!= ']')
545 return -1; /* a is shorter therefore lesser. */
546 return 0; /* a and b are identical. */
550 * Function: compare_selectors (const void *, const void *)
552 * Comparison function for use with qsort. Arguments are symbols or
553 * msymbols Compares selector part of objc method name alphabetically.
557 compare_selectors (const void *a
, const void *b
)
559 const char *aname
, *bname
;
561 aname
= (*(struct symbol
**) a
)->print_name ();
562 bname
= (*(struct symbol
**) b
)->print_name ();
563 if (aname
== NULL
|| bname
== NULL
)
564 error (_("internal: compare_selectors(1)"));
566 aname
= strchr(aname
, ' ');
567 bname
= strchr(bname
, ' ');
568 if (aname
== NULL
|| bname
== NULL
)
569 error (_("internal: compare_selectors(2)"));
571 return specialcmp (aname
+1, bname
+1);
575 * Function: selectors_info (regexp, from_tty)
577 * Implements the "Info selectors" command. Takes an optional regexp
578 * arg. Lists all objective c selectors that match the regexp. Works
579 * by grepping thru all symbols for objective c methods. Output list
580 * is sorted and uniqued.
584 info_selectors_command (const char *regexp
, int from_tty
)
593 struct symbol
**sym_arr
;
597 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
600 if (*regexp
== '+' || *regexp
== '-')
601 { /* User wants only class methods or only instance methods. */
602 plusminus
= *regexp
++;
603 while (*regexp
== ' ' || *regexp
== '\t')
607 strcpy(myregexp
, ".*]");
610 /* Allow a few extra bytes because of the strcat below. */
611 if (sizeof (myregexp
) < strlen (regexp
) + 4)
612 error (_("Regexp is too long: %s"), regexp
);
613 strcpy(myregexp
, regexp
);
614 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
615 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
617 strcat(myregexp
, ".*]");
623 val
= re_comp (myregexp
);
625 error (_("Invalid regexp (%s): %s"), val
, regexp
);
628 /* First time thru is JUST to get max length and count. */
629 for (objfile
*objfile
: current_program_space
->objfiles ())
631 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
634 name
= msymbol
->natural_name ();
636 && (name
[0] == '-' || name
[0] == '+')
637 && name
[1] == '[') /* Got a method name. */
639 /* Filter for class/instance methods. */
640 if (plusminus
&& name
[0] != plusminus
)
642 /* Find selector part. */
643 name
= (char *) strchr (name
+2, ' ');
646 complaint (_("Bad method name '%s'"),
647 msymbol
->natural_name ());
650 if (regexp
== NULL
|| re_exec(++name
) != 0)
652 const char *mystart
= name
;
653 const char *myend
= strchr (mystart
, ']');
655 if (myend
&& (myend
- mystart
> maxlen
))
656 maxlen
= myend
- mystart
; /* Get longest selector. */
664 printf_filtered (_("Selectors matching \"%s\":\n\n"),
665 regexp
? regexp
: "*");
667 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
669 for (objfile
*objfile
: current_program_space
->objfiles ())
671 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
674 name
= msymbol
->natural_name ();
676 (name
[0] == '-' || name
[0] == '+') &&
677 name
[1] == '[') /* Got a method name. */
679 /* Filter for class/instance methods. */
680 if (plusminus
&& name
[0] != plusminus
)
682 /* Find selector part. */
683 name
= (char *) strchr(name
+2, ' ');
684 if (regexp
== NULL
|| re_exec(++name
) != 0)
685 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
690 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
692 /* Prevent compare on first iteration. */
694 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
699 name
= sym_arr
[ix
]->natural_name ();
700 name
= strchr (name
, ' ') + 1;
701 if (p
[0] && specialcmp(name
, p
) == 0)
702 continue; /* Seen this one already (not unique). */
704 /* Copy selector part. */
705 while (*name
&& *name
!= ']')
708 /* Print in columns. */
709 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
714 printf_filtered (_("No selectors matching \"%s\"\n"),
715 regexp
? regexp
: "*");
719 * Function: compare_classes (const void *, const void *)
721 * Comparison function for use with qsort. Arguments are symbols or
722 * msymbols Compares class part of objc method name alphabetically.
726 compare_classes (const void *a
, const void *b
)
728 const char *aname
, *bname
;
730 aname
= (*(struct symbol
**) a
)->print_name ();
731 bname
= (*(struct symbol
**) b
)->print_name ();
732 if (aname
== NULL
|| bname
== NULL
)
733 error (_("internal: compare_classes(1)"));
735 return specialcmp (aname
+1, bname
+1);
739 * Function: classes_info(regexp, from_tty)
741 * Implements the "info classes" command for objective c classes.
742 * Lists all objective c classes that match the optional regexp.
743 * Works by grepping thru the list of objective c methods. List will
744 * be sorted and uniqued (since one class may have many methods).
745 * BUGS: will not list a class that has no methods.
749 info_classes_command (const char *regexp
, int from_tty
)
758 struct symbol
**sym_arr
;
761 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
764 /* Allow a few extra bytes because of the strcat below. */
765 if (sizeof (myregexp
) < strlen (regexp
) + 4)
766 error (_("Regexp is too long: %s"), regexp
);
767 strcpy(myregexp
, regexp
);
768 if (myregexp
[strlen(myregexp
) - 1] == '$')
769 /* In the method name, the end of the class name is marked by ' '. */
770 myregexp
[strlen(myregexp
) - 1] = ' ';
772 strcat(myregexp
, ".* ");
777 val
= re_comp (myregexp
);
779 error (_("Invalid regexp (%s): %s"), val
, regexp
);
782 /* First time thru is JUST to get max length and count. */
783 for (objfile
*objfile
: current_program_space
->objfiles ())
785 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
788 name
= msymbol
->natural_name ();
790 (name
[0] == '-' || name
[0] == '+') &&
791 name
[1] == '[') /* Got a method name. */
792 if (regexp
== NULL
|| re_exec(name
+2) != 0)
794 /* Compute length of classname part. */
795 const char *mystart
= name
+ 2;
796 const char *myend
= strchr (mystart
, ' ');
798 if (myend
&& (myend
- mystart
> maxlen
))
799 maxlen
= myend
- mystart
;
806 printf_filtered (_("Classes matching \"%s\":\n\n"),
807 regexp
? regexp
: "*");
808 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
810 for (objfile
*objfile
: current_program_space
->objfiles ())
812 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
815 name
= msymbol
->natural_name ();
817 (name
[0] == '-' || name
[0] == '+') &&
818 name
[1] == '[') /* Got a method name. */
819 if (regexp
== NULL
|| re_exec(name
+2) != 0)
820 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
824 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
826 /* Prevent compare on first iteration. */
828 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
833 name
= sym_arr
[ix
]->natural_name ();
835 if (p
[0] && specialcmp(name
, p
) == 0)
836 continue; /* Seen this one already (not unique). */
838 /* Copy class part of method name. */
839 while (*name
&& *name
!= ' ')
842 /* Print in columns. */
843 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
848 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
852 parse_selector (char *method
, char **selector
)
858 char *nselector
= NULL
;
860 gdb_assert (selector
!= NULL
);
864 s1
= skip_spaces (s1
);
870 s1
= skip_spaces (s1
);
877 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
879 else if (isspace (*s2
))
881 else if ((*s2
== '\0') || (*s2
== '\''))
889 s2
= skip_spaces (s2
);
894 s2
= skip_spaces (s2
);
897 if (selector
!= NULL
)
898 *selector
= nselector
;
904 parse_method (char *method
, char *type
, char **theclass
,
905 char **category
, char **selector
)
913 char *ncategory
= NULL
;
914 char *nselector
= NULL
;
916 gdb_assert (type
!= NULL
);
917 gdb_assert (theclass
!= NULL
);
918 gdb_assert (category
!= NULL
);
919 gdb_assert (selector
!= NULL
);
923 s1
= skip_spaces (s1
);
929 s1
= skip_spaces (s1
);
931 if ((s1
[0] == '+') || (s1
[0] == '-'))
934 s1
= skip_spaces (s1
);
941 while (isalnum (*s1
) || (*s1
== '_'))
945 s2
= skip_spaces (s2
);
950 s2
= skip_spaces (s2
);
952 while (isalnum (*s2
) || (*s2
== '_'))
957 /* Truncate the class name now that we're not using the open paren. */
965 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
967 else if (isspace (*s2
))
978 s2
= skip_spaces (s2
);
984 s2
= skip_spaces (s2
);
989 if (theclass
!= NULL
)
991 if (category
!= NULL
)
992 *category
= ncategory
;
993 if (selector
!= NULL
)
994 *selector
= nselector
;
1000 find_methods (char type
, const char *theclass
, const char *category
,
1001 const char *selector
,
1002 std::vector
<const char *> *symbol_names
)
1004 const char *symname
= NULL
;
1007 char *nclass
= NULL
;
1008 char *ncategory
= NULL
;
1009 char *nselector
= NULL
;
1011 static char *tmp
= NULL
;
1012 static unsigned int tmplen
= 0;
1014 gdb_assert (symbol_names
!= NULL
);
1016 for (objfile
*objfile
: current_program_space
->objfiles ())
1018 unsigned int *objc_csym
;
1020 /* The objfile_csym variable counts the number of ObjC methods
1021 that this objfile defines. We save that count as a private
1022 objfile data. If we have already determined that this objfile
1023 provides no ObjC methods, we can skip it entirely. */
1025 unsigned int objfile_csym
= 0;
1027 objc_csym
= objc_objfile_data
.get (objfile
);
1028 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1029 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1032 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1036 /* Check the symbol name first as this can be done entirely without
1037 sending any query to the target. */
1038 symname
= msymbol
->natural_name ();
1039 if (symname
== NULL
)
1042 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1043 /* Not a method name. */
1048 /* Now that thinks are a bit sane, clean up the symname. */
1049 while ((strlen (symname
) + 1) >= tmplen
)
1051 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1052 tmp
= (char *) xrealloc (tmp
, tmplen
);
1054 strcpy (tmp
, symname
);
1056 if (parse_method (tmp
, &ntype
, &nclass
,
1057 &ncategory
, &nselector
) == NULL
)
1060 if ((type
!= '\0') && (ntype
!= type
))
1063 if ((theclass
!= NULL
)
1064 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1067 if ((category
!= NULL
) &&
1068 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1071 if ((selector
!= NULL
) &&
1072 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1075 symbol_names
->push_back (symname
);
1078 if (objc_csym
== NULL
)
1079 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1081 /* Count of ObjC methods in this objfile should be constant. */
1082 gdb_assert (*objc_csym
== objfile_csym
);
1086 /* Uniquify a vector of strings. */
1089 uniquify_strings (std::vector
<const char *> *strings
)
1091 if (strings
->empty ())
1094 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1095 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1100 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1102 * Input: a string representing a selector
1103 * a pointer to an array of symbol pointers
1104 * possibly a pointer to a symbol found by the caller.
1106 * Output: number of methods that implement that selector. Side
1107 * effects: The array of symbol pointers is filled with matching syms.
1109 * By analogy with function "find_methods" (symtab.c), builds a list
1110 * of symbols matching the ambiguous input, so that "decode_line_2"
1111 * (symtab.c) can list them and ask the user to choose one or more.
1112 * In this case the matches are objective c methods
1113 * ("implementations") matching an objective c selector.
1115 * Note that it is possible for a normal (c-style) function to have
1116 * the same name as an objective c selector. To prevent the selector
1117 * from eclipsing the function, we allow the caller (decode_line_1) to
1118 * search for such a function first, and if it finds one, pass it in
1119 * to us. We will then integrate it into the list. We also search
1120 * for one here, among the minsyms.
1122 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1123 * into two parts: debuggable (struct symbol) syms, and
1124 * non_debuggable (struct minimal_symbol) syms. The debuggable
1125 * ones will come first, before NUM_DEBUGGABLE (which will thus
1126 * be the index of the first non-debuggable one).
1130 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1133 char *theclass
= NULL
;
1134 char *category
= NULL
;
1135 char *selector
= NULL
;
1140 int selector_case
= 0;
1142 gdb_assert (symbol_names
!= NULL
);
1144 buf
= (char *) alloca (strlen (method
) + 1);
1145 strcpy (buf
, method
);
1146 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1150 strcpy (buf
, method
);
1151 tmp
= parse_selector (buf
, &selector
);
1159 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1161 /* If we hit the "selector" case, and we found some methods, then
1162 add the selector itself as a symbol, if it exists. */
1163 if (selector_case
&& !symbol_names
->empty ())
1165 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1169 symbol_names
->push_back (sym
->natural_name ());
1172 struct bound_minimal_symbol msym
1173 = lookup_minimal_symbol (selector
, 0, 0);
1175 if (msym
.minsym
!= NULL
)
1176 symbol_names
->push_back (msym
.minsym
->natural_name ());
1180 uniquify_strings (symbol_names
);
1182 return method
+ (tmp
- buf
);
1186 print_object_command (const char *args
, int from_tty
)
1188 struct value
*object
, *function
, *description
;
1189 CORE_ADDR string_addr
, object_addr
;
1193 if (!args
|| !*args
)
1195 "The 'print-object' command requires an argument (an Objective-C object)");
1198 expression_up expr
= parse_expression (args
);
1201 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1202 expr
.get (), &pc
, EVAL_NORMAL
);
1205 /* Validate the address for sanity. */
1206 object_addr
= value_as_long (object
);
1207 read_memory (object_addr
, &c
, 1);
1209 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1210 if (function
== NULL
)
1211 error (_("Unable to locate _NSPrintForDebugger in child process"));
1213 description
= call_function_by_hand (function
, NULL
, object
);
1215 string_addr
= value_as_long (description
);
1216 if (string_addr
== 0)
1217 error (_("object returns null description"));
1219 read_memory (string_addr
+ i
++, &c
, 1);
1222 { /* Read and print characters up to EOS. */
1224 printf_filtered ("%c", c
);
1225 read_memory (string_addr
+ i
++, &c
, 1);
1228 printf_filtered(_("<object returns empty description>"));
1229 printf_filtered ("\n");
1232 /* The data structure 'methcalls' is used to detect method calls (thru
1233 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1234 * and ultimately find the method being called.
1237 struct objc_methcall
{
1239 /* Return instance method to be called. */
1240 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1241 /* Start of pc range corresponding to method invocation. */
1243 /* End of pc range corresponding to method invocation. */
1247 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1248 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1249 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1250 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1252 static struct objc_methcall methcalls
[] = {
1253 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1254 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1255 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1256 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1257 { "_objc_getClass", NULL
, 0, 0},
1258 { "_objc_getMetaClass", NULL
, 0, 0}
1261 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1263 /* The following function, "find_objc_msgsend", fills in the data
1264 * structure "objc_msgs" by finding the addresses of each of the
1265 * (currently four) functions that it holds (of which objc_msgSend is
1266 * the first). This must be called each time symbols are loaded, in
1267 * case the functions have moved for some reason.
1271 find_objc_msgsend (void)
1275 for (i
= 0; i
< nmethcalls
; i
++)
1277 struct bound_minimal_symbol func
;
1279 /* Try both with and without underscore. */
1280 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1281 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1283 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1285 if (func
.minsym
== NULL
)
1287 methcalls
[i
].begin
= 0;
1288 methcalls
[i
].end
= 0;
1292 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1293 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1297 /* find_objc_msgcall (replaces pc_off_limits)
1299 * ALL that this function now does is to determine whether the input
1300 * address ("pc") is the address of one of the Objective-C message
1301 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1302 * if so, it returns the address of the method that will be called.
1304 * The old function "pc_off_limits" used to do a lot of other things
1305 * in addition, such as detecting shared library jump stubs and
1306 * returning the address of the shlib function that would be called.
1307 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1308 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1309 * dependent modules.
1313 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1319 if (f (pc
, new_pc
) == 0)
1322 catch (const gdb_exception
&ex
)
1324 exception_fprintf (gdb_stderr
, ex
,
1325 "Unable to determine target of "
1326 "Objective-C method call (ignoring):\n");
1333 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1337 find_objc_msgsend ();
1343 for (i
= 0; i
< nmethcalls
; i
++)
1344 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1346 if (methcalls
[i
].stop_at
!= NULL
)
1347 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1356 void _initialize_objc_language ();
1358 _initialize_objc_language ()
1360 add_info ("selectors", info_selectors_command
,
1361 _("All Objective-C selectors, or those matching REGEXP."));
1362 add_info ("classes", info_classes_command
,
1363 _("All Objective-C classes, or those matching REGEXP."));
1364 add_com ("print-object", class_vars
, print_object_command
,
1365 _("Ask an Objective-C object to print itself."));
1366 add_com_alias ("po", "print-object", class_vars
, 1);
1370 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1371 struct objc_method
*method
)
1373 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1375 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1376 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1377 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1380 static unsigned long
1381 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1383 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1385 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1389 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1390 unsigned long num
, struct objc_method
*method
)
1392 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1393 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1397 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1398 struct objc_object
*object
)
1400 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1402 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1406 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1407 struct objc_super
*super
)
1409 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1411 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1412 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1416 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1417 struct objc_class
*theclass
)
1419 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1421 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1422 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1423 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1424 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1425 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1426 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1428 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1429 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1430 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1431 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1435 find_implementation_from_class (struct gdbarch
*gdbarch
,
1436 CORE_ADDR theclass
, CORE_ADDR sel
)
1438 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1439 CORE_ADDR subclass
= theclass
;
1441 while (subclass
!= 0)
1444 struct objc_class class_str
;
1445 unsigned mlistnum
= 0;
1447 read_objc_class (gdbarch
, subclass
, &class_str
);
1452 unsigned long nmethods
;
1455 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1461 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1463 for (i
= 0; i
< nmethods
; i
++)
1465 struct objc_method meth_str
;
1467 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1469 if (meth_str
.name
== sel
)
1470 /* FIXME: hppa arch was doing a pointer dereference
1471 here. There needs to be a better way to do that. */
1472 return meth_str
.imp
;
1476 subclass
= class_str
.super_class
;
1483 find_implementation (struct gdbarch
*gdbarch
,
1484 CORE_ADDR object
, CORE_ADDR sel
)
1486 struct objc_object ostr
;
1490 read_objc_object (gdbarch
, object
, &ostr
);
1494 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1498 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1500 struct frame_info
*frame
= get_current_frame ();
1501 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1502 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1508 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1509 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1511 res
= find_implementation (gdbarch
, object
, sel
);
1520 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1522 struct frame_info
*frame
= get_current_frame ();
1523 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1524 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1530 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1531 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1533 res
= find_implementation (gdbarch
, object
, sel
);
1542 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1544 struct frame_info
*frame
= get_current_frame ();
1545 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1546 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1548 struct objc_super sstr
;
1554 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1555 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1557 read_objc_super (gdbarch
, super
, &sstr
);
1558 if (sstr
.theclass
== 0)
1561 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1570 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1572 struct frame_info
*frame
= get_current_frame ();
1573 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1574 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1576 struct objc_super sstr
;
1582 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1583 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1585 read_objc_super (gdbarch
, super
, &sstr
);
1586 if (sstr
.theclass
== 0)
1589 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);