1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2021 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"
40 #include "gdb_regex.h"
45 #include "cli/cli-utils.h"
57 CORE_ADDR super_class
;
79 static const struct objfile_key
<unsigned int> objc_objfile_data
;
81 /* Lookup a structure type named "struct NAME", visible in lexical
82 block BLOCK. If NOERR is nonzero, return zero if NAME is not
86 lookup_struct_typedef (const char *name
, const struct block
*block
, int noerr
)
90 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
97 error (_("No struct type named %s."), name
);
99 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
104 error (_("This context has class, union or enum %s, not a struct."),
111 lookup_objc_class (struct gdbarch
*gdbarch
, const char *classname
)
113 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
114 struct value
* function
, *classval
;
116 if (! target_has_execution ())
118 /* Can't call into inferior to lookup class. */
122 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0).minsym
)
123 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
124 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym
)
125 function
= find_function_in_inferior("objc_lookup_class", NULL
);
128 complaint (_("no way to lookup Objective-C classes"));
132 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
133 classval
= value_coerce_array (classval
);
134 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
140 lookup_child_selector (struct gdbarch
*gdbarch
, const char *selname
)
142 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
143 struct value
* function
, *selstring
;
145 if (! target_has_execution ())
147 /* Can't call into inferior to lookup selector. */
151 if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym
)
152 function
= find_function_in_inferior("sel_getUid", NULL
);
153 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym
)
154 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
157 complaint (_("no way to lookup Objective-C selectors"));
161 selstring
= value_coerce_array (value_string (selname
,
162 strlen (selname
) + 1,
164 return value_as_long (call_function_by_hand (function
, NULL
, selstring
));
168 value_nsstring (struct gdbarch
*gdbarch
, const char *ptr
, int len
)
170 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
171 struct value
*stringValue
[3];
172 struct value
*function
, *nsstringValue
;
176 if (!target_has_execution ())
177 return 0; /* Can't call into inferior to create NSString. */
179 stringValue
[2] = value_string(ptr
, len
, char_type
);
180 stringValue
[2] = value_coerce_array(stringValue
[2]);
181 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
182 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym
)
184 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
185 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
187 else if (lookup_minimal_symbol("istr", 0, 0).minsym
)
189 function
= find_function_in_inferior("istr", NULL
);
190 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
192 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym
)
195 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
196 type
= builtin_type (gdbarch
)->builtin_long
;
198 stringValue
[0] = value_from_longest
199 (type
, lookup_objc_class (gdbarch
, "NSString"));
200 stringValue
[1] = value_from_longest
201 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
202 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
);
205 error (_("NSString: internal error -- no way to create new NSString"));
207 sym
= lookup_struct_typedef("NSString", 0, 1);
209 sym
= lookup_struct_typedef("NXString", 0, 1);
211 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
213 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
215 deprecated_set_value_type (nsstringValue
, type
);
216 return nsstringValue
;
219 /* Objective-C name demangling. */
222 objc_demangle (const char *mangled
, int options
)
224 char *demangled
, *cp
;
226 if (mangled
[0] == '_' &&
227 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
230 cp
= demangled
= (char *) xmalloc (strlen (mangled
) + 2);
232 if (mangled
[1] == 'i')
233 *cp
++ = '-'; /* for instance method */
235 *cp
++ = '+'; /* for class method */
237 *cp
++ = '['; /* opening left brace */
238 strcpy(cp
, mangled
+3); /* Tack on the rest of the mangled name. */
240 while (*cp
&& *cp
== '_')
241 cp
++; /* Skip any initial underbars in class
244 cp
= strchr(cp
, '_');
245 if (!cp
) /* Find first non-initial underbar. */
247 xfree(demangled
); /* not mangled name */
250 if (cp
[1] == '_') /* Easy case: no category name. */
252 *cp
++ = ' '; /* Replace two '_' with one ' '. */
253 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
257 *cp
++ = '('; /* Less easy case: category name. */
258 cp
= strchr(cp
, '_');
261 xfree(demangled
); /* not mangled name */
265 *cp
++ = ' '; /* Overwriting 1st char of method name... */
266 strcpy(cp
, mangled
+ (cp
- demangled
)); /* Get it back. */
269 while (*cp
&& *cp
== '_')
270 cp
++; /* Skip any initial underbars in
275 *cp
= ':'; /* Replace remaining '_' with ':'. */
277 *cp
++ = ']'; /* closing right brace */
278 *cp
++ = 0; /* string terminator */
282 return NULL
; /* Not an objc mangled name. */
285 /* Class representing the Objective-C language. */
287 class objc_language
: public language_defn
291 : language_defn (language_objc
)
294 /* See language.h. */
296 const char *name () const override
297 { return "objective-c"; }
299 /* See language.h. */
301 const char *natural_name () const override
302 { return "Objective-C"; }
304 /* See language.h. */
306 const std::vector
<const char *> &filename_extensions () const override
308 static const std::vector
<const char *> extensions
= { ".m" };
312 /* See language.h. */
313 void language_arch_info (struct gdbarch
*gdbarch
,
314 struct language_arch_info
*lai
) const override
316 c_language_arch_info (gdbarch
, lai
);
319 /* See language.h. */
320 bool sniff_from_mangled_name (const char *mangled
,
321 char **demangled
) const override
323 *demangled
= objc_demangle (mangled
, 0);
324 return *demangled
!= NULL
;
327 /* See language.h. */
329 char *demangle_symbol (const char *mangled
, int options
) const override
331 return objc_demangle (mangled
, options
);
334 /* See language.h. */
336 void print_type (struct type
*type
, const char *varstring
,
337 struct ui_file
*stream
, int show
, int level
,
338 const struct type_print_options
*flags
) const override
340 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
343 /* See language.h. */
345 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
346 CORE_ADDR stop_pc
) const override
348 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
349 CORE_ADDR real_stop_pc
;
350 CORE_ADDR method_stop_pc
;
352 /* Determine if we are currently in the Objective-C dispatch function.
353 If so, get the address of the method function that the dispatcher
354 would call and use that as the function to step into instead. Also
355 skip over the trampoline for the function (if any). This is better
356 for the user since they are only interested in stepping into the
357 method function anyway. */
359 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
361 if (real_stop_pc
!= 0)
362 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
364 find_objc_msgcall (stop_pc
, &method_stop_pc
);
368 real_stop_pc
= gdbarch_skip_trampoline_code
369 (gdbarch
, frame
, method_stop_pc
);
370 if (real_stop_pc
== 0)
371 real_stop_pc
= method_stop_pc
;
377 /* See language.h. */
379 const char *name_of_this () const override
382 /* See language.h. */
384 enum macro_expansion
macro_expansion () const override
385 { return macro_expansion_c
; }
388 /* Single instance of the class representing the Objective-C language. */
390 static objc_language objc_language_defn
;
394 * Following functions help construct Objective-C message calls.
397 struct selname
/* For parsing Objective-C. */
399 struct selname
*next
;
404 static int msglist_len
;
405 static struct selname
*selname_chain
;
406 static char *msglist_sel
;
411 struct selname
*newobj
= XNEW (struct selname
);
413 newobj
->next
= selname_chain
;
414 newobj
->msglist_len
= msglist_len
;
415 newobj
->msglist_sel
= msglist_sel
;
417 msglist_sel
= (char *)xmalloc(1);
419 selname_chain
= newobj
;
423 add_msglist(struct stoken
*str
, int addcolon
)
429 if (str
== 0) /* Unnamed arg, or... */
431 if (addcolon
== 0) /* variable number of args. */
444 len
= plen
+ strlen(msglist_sel
) + 2;
445 s
= (char *)xmalloc(len
);
446 strcpy(s
, msglist_sel
);
461 end_msglist (struct parser_state
*ps
)
463 int val
= msglist_len
;
464 struct selname
*sel
= selname_chain
;
465 char *p
= msglist_sel
;
468 std::vector
<expr::operation_up
> args
= ps
->pop_vector (val
);
469 expr::operation_up target
= ps
->pop ();
471 selname_chain
= sel
->next
;
472 msglist_len
= sel
->msglist_len
;
473 msglist_sel
= sel
->msglist_sel
;
474 selid
= lookup_child_selector (ps
->gdbarch (), p
);
476 error (_("Can't find selector \"%s\""), p
);
478 ps
->push_new
<expr::objc_msgcall_operation
> (selid
, std::move (target
),
488 * Function: specialcmp (const char *a, const char *b)
490 * Special strcmp: treats ']' and ' ' as end-of-string.
491 * Used for qsorting lists of objc methods (either by class or selector).
495 specialcmp (const char *a
, const char *b
)
497 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
503 if (*a
&& *a
!= ' ' && *a
!= ']')
504 return 1; /* a is longer therefore greater. */
505 if (*b
&& *b
!= ' ' && *b
!= ']')
506 return -1; /* a is shorter therefore lesser. */
507 return 0; /* a and b are identical. */
511 * Function: compare_selectors (const void *, const void *)
513 * Comparison function for use with qsort. Arguments are symbols or
514 * msymbols Compares selector part of objc method name alphabetically.
518 compare_selectors (const void *a
, const void *b
)
520 const char *aname
, *bname
;
522 aname
= (*(struct symbol
**) a
)->print_name ();
523 bname
= (*(struct symbol
**) b
)->print_name ();
524 if (aname
== NULL
|| bname
== NULL
)
525 error (_("internal: compare_selectors(1)"));
527 aname
= strchr(aname
, ' ');
528 bname
= strchr(bname
, ' ');
529 if (aname
== NULL
|| bname
== NULL
)
530 error (_("internal: compare_selectors(2)"));
532 return specialcmp (aname
+1, bname
+1);
536 * Function: selectors_info (regexp, from_tty)
538 * Implements the "Info selectors" command. Takes an optional regexp
539 * arg. Lists all objective c selectors that match the regexp. Works
540 * by grepping thru all symbols for objective c methods. Output list
541 * is sorted and uniqued.
545 info_selectors_command (const char *regexp
, int from_tty
)
554 struct symbol
**sym_arr
;
558 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
561 if (*regexp
== '+' || *regexp
== '-')
562 { /* User wants only class methods or only instance methods. */
563 plusminus
= *regexp
++;
564 while (*regexp
== ' ' || *regexp
== '\t')
568 strcpy(myregexp
, ".*]");
571 /* Allow a few extra bytes because of the strcat below. */
572 if (sizeof (myregexp
) < strlen (regexp
) + 4)
573 error (_("Regexp is too long: %s"), regexp
);
574 strcpy(myregexp
, regexp
);
575 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
576 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
578 strcat(myregexp
, ".*]");
584 val
= re_comp (myregexp
);
586 error (_("Invalid regexp (%s): %s"), val
, regexp
);
589 /* First time thru is JUST to get max length and count. */
590 for (objfile
*objfile
: current_program_space
->objfiles ())
592 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
595 name
= msymbol
->natural_name ();
597 && (name
[0] == '-' || name
[0] == '+')
598 && name
[1] == '[') /* Got a method name. */
600 /* Filter for class/instance methods. */
601 if (plusminus
&& name
[0] != plusminus
)
603 /* Find selector part. */
604 name
= (char *) strchr (name
+2, ' ');
607 complaint (_("Bad method name '%s'"),
608 msymbol
->natural_name ());
611 if (regexp
== NULL
|| re_exec(++name
) != 0)
613 const char *mystart
= name
;
614 const char *myend
= strchr (mystart
, ']');
616 if (myend
&& (myend
- mystart
> maxlen
))
617 maxlen
= myend
- mystart
; /* Get longest selector. */
625 printf_filtered (_("Selectors matching \"%s\":\n\n"),
626 regexp
? regexp
: "*");
628 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
630 for (objfile
*objfile
: current_program_space
->objfiles ())
632 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
635 name
= msymbol
->natural_name ();
637 (name
[0] == '-' || name
[0] == '+') &&
638 name
[1] == '[') /* Got a method name. */
640 /* Filter for class/instance methods. */
641 if (plusminus
&& name
[0] != plusminus
)
643 /* Find selector part. */
644 name
= (char *) strchr(name
+2, ' ');
645 if (regexp
== NULL
|| re_exec(++name
) != 0)
646 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
651 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
653 /* Prevent compare on first iteration. */
655 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
660 name
= sym_arr
[ix
]->natural_name ();
661 name
= strchr (name
, ' ') + 1;
662 if (p
[0] && specialcmp(name
, p
) == 0)
663 continue; /* Seen this one already (not unique). */
665 /* Copy selector part. */
666 while (*name
&& *name
!= ']')
669 /* Print in columns. */
670 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
675 printf_filtered (_("No selectors matching \"%s\"\n"),
676 regexp
? regexp
: "*");
680 * Function: compare_classes (const void *, const void *)
682 * Comparison function for use with qsort. Arguments are symbols or
683 * msymbols Compares class part of objc method name alphabetically.
687 compare_classes (const void *a
, const void *b
)
689 const char *aname
, *bname
;
691 aname
= (*(struct symbol
**) a
)->print_name ();
692 bname
= (*(struct symbol
**) b
)->print_name ();
693 if (aname
== NULL
|| bname
== NULL
)
694 error (_("internal: compare_classes(1)"));
696 return specialcmp (aname
+1, bname
+1);
700 * Function: classes_info(regexp, from_tty)
702 * Implements the "info classes" command for objective c classes.
703 * Lists all objective c classes that match the optional regexp.
704 * Works by grepping thru the list of objective c methods. List will
705 * be sorted and uniqued (since one class may have many methods).
706 * BUGS: will not list a class that has no methods.
710 info_classes_command (const char *regexp
, int from_tty
)
719 struct symbol
**sym_arr
;
722 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
725 /* Allow a few extra bytes because of the strcat below. */
726 if (sizeof (myregexp
) < strlen (regexp
) + 4)
727 error (_("Regexp is too long: %s"), regexp
);
728 strcpy(myregexp
, regexp
);
729 if (myregexp
[strlen(myregexp
) - 1] == '$')
730 /* In the method name, the end of the class name is marked by ' '. */
731 myregexp
[strlen(myregexp
) - 1] = ' ';
733 strcat(myregexp
, ".* ");
738 val
= re_comp (myregexp
);
740 error (_("Invalid regexp (%s): %s"), val
, regexp
);
743 /* First time thru is JUST to get max length and count. */
744 for (objfile
*objfile
: current_program_space
->objfiles ())
746 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
749 name
= msymbol
->natural_name ();
751 (name
[0] == '-' || name
[0] == '+') &&
752 name
[1] == '[') /* Got a method name. */
753 if (regexp
== NULL
|| re_exec(name
+2) != 0)
755 /* Compute length of classname part. */
756 const char *mystart
= name
+ 2;
757 const char *myend
= strchr (mystart
, ' ');
759 if (myend
&& (myend
- mystart
> maxlen
))
760 maxlen
= myend
- mystart
;
767 printf_filtered (_("Classes matching \"%s\":\n\n"),
768 regexp
? regexp
: "*");
769 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
771 for (objfile
*objfile
: current_program_space
->objfiles ())
773 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
776 name
= msymbol
->natural_name ();
778 (name
[0] == '-' || name
[0] == '+') &&
779 name
[1] == '[') /* Got a method name. */
780 if (regexp
== NULL
|| re_exec(name
+2) != 0)
781 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
785 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
787 /* Prevent compare on first iteration. */
789 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
794 name
= sym_arr
[ix
]->natural_name ();
796 if (p
[0] && specialcmp(name
, p
) == 0)
797 continue; /* Seen this one already (not unique). */
799 /* Copy class part of method name. */
800 while (*name
&& *name
!= ' ')
803 /* Print in columns. */
804 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
809 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
813 parse_selector (char *method
, char **selector
)
819 char *nselector
= NULL
;
821 gdb_assert (selector
!= NULL
);
825 s1
= skip_spaces (s1
);
831 s1
= skip_spaces (s1
);
838 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
840 else if (isspace (*s2
))
842 else if ((*s2
== '\0') || (*s2
== '\''))
850 s2
= skip_spaces (s2
);
855 s2
= skip_spaces (s2
);
858 if (selector
!= NULL
)
859 *selector
= nselector
;
865 parse_method (char *method
, char *type
, char **theclass
,
866 char **category
, char **selector
)
874 char *ncategory
= NULL
;
875 char *nselector
= NULL
;
877 gdb_assert (type
!= NULL
);
878 gdb_assert (theclass
!= NULL
);
879 gdb_assert (category
!= NULL
);
880 gdb_assert (selector
!= NULL
);
884 s1
= skip_spaces (s1
);
890 s1
= skip_spaces (s1
);
892 if ((s1
[0] == '+') || (s1
[0] == '-'))
895 s1
= skip_spaces (s1
);
902 while (isalnum (*s1
) || (*s1
== '_'))
906 s2
= skip_spaces (s2
);
911 s2
= skip_spaces (s2
);
913 while (isalnum (*s2
) || (*s2
== '_'))
918 /* Truncate the class name now that we're not using the open paren. */
926 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
928 else if (isspace (*s2
))
939 s2
= skip_spaces (s2
);
945 s2
= skip_spaces (s2
);
950 if (theclass
!= NULL
)
952 if (category
!= NULL
)
953 *category
= ncategory
;
954 if (selector
!= NULL
)
955 *selector
= nselector
;
961 find_methods (char type
, const char *theclass
, const char *category
,
962 const char *selector
,
963 std::vector
<const char *> *symbol_names
)
965 const char *symname
= NULL
;
969 char *ncategory
= NULL
;
970 char *nselector
= NULL
;
972 static char *tmp
= NULL
;
973 static unsigned int tmplen
= 0;
975 gdb_assert (symbol_names
!= NULL
);
977 for (objfile
*objfile
: current_program_space
->objfiles ())
979 unsigned int *objc_csym
;
981 /* The objfile_csym variable counts the number of ObjC methods
982 that this objfile defines. We save that count as a private
983 objfile data. If we have already determined that this objfile
984 provides no ObjC methods, we can skip it entirely. */
986 unsigned int objfile_csym
= 0;
988 objc_csym
= objc_objfile_data
.get (objfile
);
989 if (objc_csym
!= NULL
&& *objc_csym
== 0)
990 /* There are no ObjC symbols in this objfile. Skip it entirely. */
993 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
997 /* Check the symbol name first as this can be done entirely without
998 sending any query to the target. */
999 symname
= msymbol
->natural_name ();
1000 if (symname
== NULL
)
1003 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1004 /* Not a method name. */
1009 /* Now that thinks are a bit sane, clean up the symname. */
1010 while ((strlen (symname
) + 1) >= tmplen
)
1012 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1013 tmp
= (char *) xrealloc (tmp
, tmplen
);
1015 strcpy (tmp
, symname
);
1017 if (parse_method (tmp
, &ntype
, &nclass
,
1018 &ncategory
, &nselector
) == NULL
)
1021 if ((type
!= '\0') && (ntype
!= type
))
1024 if ((theclass
!= NULL
)
1025 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1028 if ((category
!= NULL
) &&
1029 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1032 if ((selector
!= NULL
) &&
1033 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1036 symbol_names
->push_back (symname
);
1039 if (objc_csym
== NULL
)
1040 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1042 /* Count of ObjC methods in this objfile should be constant. */
1043 gdb_assert (*objc_csym
== objfile_csym
);
1047 /* Uniquify a vector of strings. */
1050 uniquify_strings (std::vector
<const char *> *strings
)
1052 if (strings
->empty ())
1055 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1056 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1061 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1063 * Input: a string representing a selector
1064 * a pointer to an array of symbol pointers
1065 * possibly a pointer to a symbol found by the caller.
1067 * Output: number of methods that implement that selector. Side
1068 * effects: The array of symbol pointers is filled with matching syms.
1070 * By analogy with function "find_methods" (symtab.c), builds a list
1071 * of symbols matching the ambiguous input, so that "decode_line_2"
1072 * (symtab.c) can list them and ask the user to choose one or more.
1073 * In this case the matches are objective c methods
1074 * ("implementations") matching an objective c selector.
1076 * Note that it is possible for a normal (c-style) function to have
1077 * the same name as an objective c selector. To prevent the selector
1078 * from eclipsing the function, we allow the caller (decode_line_1) to
1079 * search for such a function first, and if it finds one, pass it in
1080 * to us. We will then integrate it into the list. We also search
1081 * for one here, among the minsyms.
1083 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1084 * into two parts: debuggable (struct symbol) syms, and
1085 * non_debuggable (struct minimal_symbol) syms. The debuggable
1086 * ones will come first, before NUM_DEBUGGABLE (which will thus
1087 * be the index of the first non-debuggable one).
1091 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1094 char *theclass
= NULL
;
1095 char *category
= NULL
;
1096 char *selector
= NULL
;
1101 int selector_case
= 0;
1103 gdb_assert (symbol_names
!= NULL
);
1105 buf
= (char *) alloca (strlen (method
) + 1);
1106 strcpy (buf
, method
);
1107 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1111 strcpy (buf
, method
);
1112 tmp
= parse_selector (buf
, &selector
);
1120 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1122 /* If we hit the "selector" case, and we found some methods, then
1123 add the selector itself as a symbol, if it exists. */
1124 if (selector_case
&& !symbol_names
->empty ())
1126 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1130 symbol_names
->push_back (sym
->natural_name ());
1133 struct bound_minimal_symbol msym
1134 = lookup_minimal_symbol (selector
, 0, 0);
1136 if (msym
.minsym
!= NULL
)
1137 symbol_names
->push_back (msym
.minsym
->natural_name ());
1141 uniquify_strings (symbol_names
);
1143 return method
+ (tmp
- buf
);
1147 print_object_command (const char *args
, int from_tty
)
1149 struct value
*object
, *function
, *description
;
1150 CORE_ADDR string_addr
, object_addr
;
1154 if (!args
|| !*args
)
1156 "The 'print-object' command requires an argument (an Objective-C object)");
1159 expression_up expr
= parse_expression (args
);
1162 = evaluate_expression (expr
.get (),
1163 builtin_type (expr
->gdbarch
)->builtin_data_ptr
);
1166 /* Validate the address for sanity. */
1167 object_addr
= value_as_long (object
);
1168 read_memory (object_addr
, &c
, 1);
1170 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1171 if (function
== NULL
)
1172 error (_("Unable to locate _NSPrintForDebugger in child process"));
1174 description
= call_function_by_hand (function
, NULL
, object
);
1176 string_addr
= value_as_long (description
);
1177 if (string_addr
== 0)
1178 error (_("object returns null description"));
1180 read_memory (string_addr
+ i
++, &c
, 1);
1183 { /* Read and print characters up to EOS. */
1185 printf_filtered ("%c", c
);
1186 read_memory (string_addr
+ i
++, &c
, 1);
1189 printf_filtered(_("<object returns empty description>"));
1190 printf_filtered ("\n");
1193 /* The data structure 'methcalls' is used to detect method calls (thru
1194 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1195 * and ultimately find the method being called.
1198 struct objc_methcall
{
1200 /* Return instance method to be called. */
1201 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1202 /* Start of pc range corresponding to method invocation. */
1204 /* End of pc range corresponding to method invocation. */
1208 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1209 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1210 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1211 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1213 static struct objc_methcall methcalls
[] = {
1214 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1215 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1216 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1217 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1218 { "_objc_getClass", NULL
, 0, 0},
1219 { "_objc_getMetaClass", NULL
, 0, 0}
1222 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1224 /* The following function, "find_objc_msgsend", fills in the data
1225 * structure "objc_msgs" by finding the addresses of each of the
1226 * (currently four) functions that it holds (of which objc_msgSend is
1227 * the first). This must be called each time symbols are loaded, in
1228 * case the functions have moved for some reason.
1232 find_objc_msgsend (void)
1236 for (i
= 0; i
< nmethcalls
; i
++)
1238 struct bound_minimal_symbol func
;
1240 /* Try both with and without underscore. */
1241 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1242 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1244 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1246 if (func
.minsym
== NULL
)
1248 methcalls
[i
].begin
= 0;
1249 methcalls
[i
].end
= 0;
1253 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1254 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1258 /* find_objc_msgcall (replaces pc_off_limits)
1260 * ALL that this function now does is to determine whether the input
1261 * address ("pc") is the address of one of the Objective-C message
1262 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1263 * if so, it returns the address of the method that will be called.
1265 * The old function "pc_off_limits" used to do a lot of other things
1266 * in addition, such as detecting shared library jump stubs and
1267 * returning the address of the shlib function that would be called.
1268 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1269 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1270 * dependent modules.
1274 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1280 if (f (pc
, new_pc
) == 0)
1283 catch (const gdb_exception
&ex
)
1285 exception_fprintf (gdb_stderr
, ex
,
1286 "Unable to determine target of "
1287 "Objective-C method call (ignoring):\n");
1294 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1298 find_objc_msgsend ();
1304 for (i
= 0; i
< nmethcalls
; i
++)
1305 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1307 if (methcalls
[i
].stop_at
!= NULL
)
1308 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1317 void _initialize_objc_language ();
1319 _initialize_objc_language ()
1321 add_info ("selectors", info_selectors_command
,
1322 _("All Objective-C selectors, or those matching REGEXP."));
1323 add_info ("classes", info_classes_command
,
1324 _("All Objective-C classes, or those matching REGEXP."));
1325 add_com ("print-object", class_vars
, print_object_command
,
1326 _("Ask an Objective-C object to print itself."));
1327 add_com_alias ("po", "print-object", class_vars
, 1);
1331 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1332 struct objc_method
*method
)
1334 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1336 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1337 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1338 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1341 static unsigned long
1342 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1344 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1346 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1350 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1351 unsigned long num
, struct objc_method
*method
)
1353 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1354 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1358 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1359 struct objc_object
*object
)
1361 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1363 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1367 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1368 struct objc_super
*super
)
1370 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1372 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1373 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1377 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1378 struct objc_class
*theclass
)
1380 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1382 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1383 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1384 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1385 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1386 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1387 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1389 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1390 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1391 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1392 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1396 find_implementation_from_class (struct gdbarch
*gdbarch
,
1397 CORE_ADDR theclass
, CORE_ADDR sel
)
1399 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1400 CORE_ADDR subclass
= theclass
;
1402 while (subclass
!= 0)
1405 struct objc_class class_str
;
1406 unsigned mlistnum
= 0;
1408 read_objc_class (gdbarch
, subclass
, &class_str
);
1413 unsigned long nmethods
;
1416 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1422 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1424 for (i
= 0; i
< nmethods
; i
++)
1426 struct objc_method meth_str
;
1428 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1430 if (meth_str
.name
== sel
)
1431 /* FIXME: hppa arch was doing a pointer dereference
1432 here. There needs to be a better way to do that. */
1433 return meth_str
.imp
;
1437 subclass
= class_str
.super_class
;
1444 find_implementation (struct gdbarch
*gdbarch
,
1445 CORE_ADDR object
, CORE_ADDR sel
)
1447 struct objc_object ostr
;
1451 read_objc_object (gdbarch
, object
, &ostr
);
1455 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1459 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1461 struct frame_info
*frame
= get_current_frame ();
1462 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1463 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1469 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1470 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1472 res
= find_implementation (gdbarch
, object
, sel
);
1481 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1483 struct frame_info
*frame
= get_current_frame ();
1484 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1485 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1491 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1492 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1494 res
= find_implementation (gdbarch
, object
, sel
);
1503 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1505 struct frame_info
*frame
= get_current_frame ();
1506 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1507 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1509 struct objc_super sstr
;
1515 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1516 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1518 read_objc_super (gdbarch
, super
, &sstr
);
1519 if (sstr
.theclass
== 0)
1522 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1531 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1533 struct frame_info
*frame
= get_current_frame ();
1534 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1535 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1537 struct objc_super sstr
;
1543 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1544 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1546 read_objc_super (gdbarch
, super
, &sstr
);
1547 if (sstr
.theclass
== 0)
1550 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);