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 c_value_print_inner
, /* la_value_print_inner */
347 c_value_print
, /* Print a top-level value */
348 "self", /* name_of_this */
349 false, /* la_store_sym_names_in_linkage_form_p */
350 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
351 objc_op_print_tab
, /* Expression operators for printing */
352 1, /* C-style arrays */
353 0, /* String lower bound */
354 default_word_break_characters
,
355 default_collect_symbol_completion_matches
,
356 c_watch_location_expression
,
359 "{...}" /* la_struct_too_deep_ellipsis */
362 /* Class representing the Objective-C language. */
364 class objc_language
: public language_defn
368 : language_defn (language_objc
, objc_language_data
)
371 /* See language.h. */
372 void language_arch_info (struct gdbarch
*gdbarch
,
373 struct language_arch_info
*lai
) const override
375 c_language_arch_info (gdbarch
, lai
);
378 /* See language.h. */
379 bool sniff_from_mangled_name (const char *mangled
,
380 char **demangled
) const override
382 *demangled
= objc_demangle (mangled
, 0);
383 return *demangled
!= NULL
;
386 /* See language.h. */
388 char *demangle (const char *mangled
, int options
) const override
390 return objc_demangle (mangled
, options
);
393 /* See language.h. */
395 void print_type (struct type
*type
, const char *varstring
,
396 struct ui_file
*stream
, int show
, int level
,
397 const struct type_print_options
*flags
) const override
399 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
402 /* See language.h. */
404 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
405 CORE_ADDR stop_pc
) const override
407 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
408 CORE_ADDR real_stop_pc
;
409 CORE_ADDR method_stop_pc
;
411 /* Determine if we are currently in the Objective-C dispatch function.
412 If so, get the address of the method function that the dispatcher
413 would call and use that as the function to step into instead. Also
414 skip over the trampoline for the function (if any). This is better
415 for the user since they are only interested in stepping into the
416 method function anyway. */
418 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
420 if (real_stop_pc
!= 0)
421 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
423 find_objc_msgcall (stop_pc
, &method_stop_pc
);
427 real_stop_pc
= gdbarch_skip_trampoline_code
428 (gdbarch
, frame
, method_stop_pc
);
429 if (real_stop_pc
== 0)
430 real_stop_pc
= method_stop_pc
;
437 /* Single instance of the class representing the Objective-C language. */
439 static objc_language objc_language_defn
;
443 * Following functions help construct Objective-C message calls.
446 struct selname
/* For parsing Objective-C. */
448 struct selname
*next
;
453 static int msglist_len
;
454 static struct selname
*selname_chain
;
455 static char *msglist_sel
;
460 struct selname
*newobj
= XNEW (struct selname
);
462 newobj
->next
= selname_chain
;
463 newobj
->msglist_len
= msglist_len
;
464 newobj
->msglist_sel
= msglist_sel
;
466 msglist_sel
= (char *)xmalloc(1);
468 selname_chain
= newobj
;
472 add_msglist(struct stoken
*str
, int addcolon
)
478 if (str
== 0) /* Unnamed arg, or... */
480 if (addcolon
== 0) /* variable number of args. */
493 len
= plen
+ strlen(msglist_sel
) + 2;
494 s
= (char *)xmalloc(len
);
495 strcpy(s
, msglist_sel
);
510 end_msglist (struct parser_state
*ps
)
512 int val
= msglist_len
;
513 struct selname
*sel
= selname_chain
;
514 char *p
= msglist_sel
;
517 selname_chain
= sel
->next
;
518 msglist_len
= sel
->msglist_len
;
519 msglist_sel
= sel
->msglist_sel
;
520 selid
= lookup_child_selector (ps
->gdbarch (), p
);
522 error (_("Can't find selector \"%s\""), p
);
523 write_exp_elt_longcst (ps
, selid
);
525 write_exp_elt_longcst (ps
, val
); /* Number of args */
532 * Function: specialcmp (const char *a, const char *b)
534 * Special strcmp: treats ']' and ' ' as end-of-string.
535 * Used for qsorting lists of objc methods (either by class or selector).
539 specialcmp (const char *a
, const char *b
)
541 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
547 if (*a
&& *a
!= ' ' && *a
!= ']')
548 return 1; /* a is longer therefore greater. */
549 if (*b
&& *b
!= ' ' && *b
!= ']')
550 return -1; /* a is shorter therefore lesser. */
551 return 0; /* a and b are identical. */
555 * Function: compare_selectors (const void *, const void *)
557 * Comparison function for use with qsort. Arguments are symbols or
558 * msymbols Compares selector part of objc method name alphabetically.
562 compare_selectors (const void *a
, const void *b
)
564 const char *aname
, *bname
;
566 aname
= (*(struct symbol
**) a
)->print_name ();
567 bname
= (*(struct symbol
**) b
)->print_name ();
568 if (aname
== NULL
|| bname
== NULL
)
569 error (_("internal: compare_selectors(1)"));
571 aname
= strchr(aname
, ' ');
572 bname
= strchr(bname
, ' ');
573 if (aname
== NULL
|| bname
== NULL
)
574 error (_("internal: compare_selectors(2)"));
576 return specialcmp (aname
+1, bname
+1);
580 * Function: selectors_info (regexp, from_tty)
582 * Implements the "Info selectors" command. Takes an optional regexp
583 * arg. Lists all objective c selectors that match the regexp. Works
584 * by grepping thru all symbols for objective c methods. Output list
585 * is sorted and uniqued.
589 info_selectors_command (const char *regexp
, int from_tty
)
598 struct symbol
**sym_arr
;
602 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
605 if (*regexp
== '+' || *regexp
== '-')
606 { /* User wants only class methods or only instance methods. */
607 plusminus
= *regexp
++;
608 while (*regexp
== ' ' || *regexp
== '\t')
612 strcpy(myregexp
, ".*]");
615 /* Allow a few extra bytes because of the strcat below. */
616 if (sizeof (myregexp
) < strlen (regexp
) + 4)
617 error (_("Regexp is too long: %s"), regexp
);
618 strcpy(myregexp
, regexp
);
619 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
620 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
622 strcat(myregexp
, ".*]");
628 val
= re_comp (myregexp
);
630 error (_("Invalid regexp (%s): %s"), val
, regexp
);
633 /* First time thru is JUST to get max length and count. */
634 for (objfile
*objfile
: current_program_space
->objfiles ())
636 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
639 name
= msymbol
->natural_name ();
641 && (name
[0] == '-' || name
[0] == '+')
642 && name
[1] == '[') /* Got a method name. */
644 /* Filter for class/instance methods. */
645 if (plusminus
&& name
[0] != plusminus
)
647 /* Find selector part. */
648 name
= (char *) strchr (name
+2, ' ');
651 complaint (_("Bad method name '%s'"),
652 msymbol
->natural_name ());
655 if (regexp
== NULL
|| re_exec(++name
) != 0)
657 const char *mystart
= name
;
658 const char *myend
= strchr (mystart
, ']');
660 if (myend
&& (myend
- mystart
> maxlen
))
661 maxlen
= myend
- mystart
; /* Get longest selector. */
669 printf_filtered (_("Selectors matching \"%s\":\n\n"),
670 regexp
? regexp
: "*");
672 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
674 for (objfile
*objfile
: current_program_space
->objfiles ())
676 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
679 name
= msymbol
->natural_name ();
681 (name
[0] == '-' || name
[0] == '+') &&
682 name
[1] == '[') /* Got a method name. */
684 /* Filter for class/instance methods. */
685 if (plusminus
&& name
[0] != plusminus
)
687 /* Find selector part. */
688 name
= (char *) strchr(name
+2, ' ');
689 if (regexp
== NULL
|| re_exec(++name
) != 0)
690 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
695 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
697 /* Prevent compare on first iteration. */
699 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
704 name
= sym_arr
[ix
]->natural_name ();
705 name
= strchr (name
, ' ') + 1;
706 if (p
[0] && specialcmp(name
, p
) == 0)
707 continue; /* Seen this one already (not unique). */
709 /* Copy selector part. */
710 while (*name
&& *name
!= ']')
713 /* Print in columns. */
714 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
719 printf_filtered (_("No selectors matching \"%s\"\n"),
720 regexp
? regexp
: "*");
724 * Function: compare_classes (const void *, const void *)
726 * Comparison function for use with qsort. Arguments are symbols or
727 * msymbols Compares class part of objc method name alphabetically.
731 compare_classes (const void *a
, const void *b
)
733 const char *aname
, *bname
;
735 aname
= (*(struct symbol
**) a
)->print_name ();
736 bname
= (*(struct symbol
**) b
)->print_name ();
737 if (aname
== NULL
|| bname
== NULL
)
738 error (_("internal: compare_classes(1)"));
740 return specialcmp (aname
+1, bname
+1);
744 * Function: classes_info(regexp, from_tty)
746 * Implements the "info classes" command for objective c classes.
747 * Lists all objective c classes that match the optional regexp.
748 * Works by grepping thru the list of objective c methods. List will
749 * be sorted and uniqued (since one class may have many methods).
750 * BUGS: will not list a class that has no methods.
754 info_classes_command (const char *regexp
, int from_tty
)
763 struct symbol
**sym_arr
;
766 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
769 /* Allow a few extra bytes because of the strcat below. */
770 if (sizeof (myregexp
) < strlen (regexp
) + 4)
771 error (_("Regexp is too long: %s"), regexp
);
772 strcpy(myregexp
, regexp
);
773 if (myregexp
[strlen(myregexp
) - 1] == '$')
774 /* In the method name, the end of the class name is marked by ' '. */
775 myregexp
[strlen(myregexp
) - 1] = ' ';
777 strcat(myregexp
, ".* ");
782 val
= re_comp (myregexp
);
784 error (_("Invalid regexp (%s): %s"), val
, regexp
);
787 /* First time thru is JUST to get max length and count. */
788 for (objfile
*objfile
: current_program_space
->objfiles ())
790 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
793 name
= msymbol
->natural_name ();
795 (name
[0] == '-' || name
[0] == '+') &&
796 name
[1] == '[') /* Got a method name. */
797 if (regexp
== NULL
|| re_exec(name
+2) != 0)
799 /* Compute length of classname part. */
800 const char *mystart
= name
+ 2;
801 const char *myend
= strchr (mystart
, ' ');
803 if (myend
&& (myend
- mystart
> maxlen
))
804 maxlen
= myend
- mystart
;
811 printf_filtered (_("Classes matching \"%s\":\n\n"),
812 regexp
? regexp
: "*");
813 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
815 for (objfile
*objfile
: current_program_space
->objfiles ())
817 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
820 name
= msymbol
->natural_name ();
822 (name
[0] == '-' || name
[0] == '+') &&
823 name
[1] == '[') /* Got a method name. */
824 if (regexp
== NULL
|| re_exec(name
+2) != 0)
825 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
829 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
831 /* Prevent compare on first iteration. */
833 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
838 name
= sym_arr
[ix
]->natural_name ();
840 if (p
[0] && specialcmp(name
, p
) == 0)
841 continue; /* Seen this one already (not unique). */
843 /* Copy class part of method name. */
844 while (*name
&& *name
!= ' ')
847 /* Print in columns. */
848 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
853 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
857 parse_selector (char *method
, char **selector
)
863 char *nselector
= NULL
;
865 gdb_assert (selector
!= NULL
);
869 s1
= skip_spaces (s1
);
875 s1
= skip_spaces (s1
);
882 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
884 else if (isspace (*s2
))
886 else if ((*s2
== '\0') || (*s2
== '\''))
894 s2
= skip_spaces (s2
);
899 s2
= skip_spaces (s2
);
902 if (selector
!= NULL
)
903 *selector
= nselector
;
909 parse_method (char *method
, char *type
, char **theclass
,
910 char **category
, char **selector
)
918 char *ncategory
= NULL
;
919 char *nselector
= NULL
;
921 gdb_assert (type
!= NULL
);
922 gdb_assert (theclass
!= NULL
);
923 gdb_assert (category
!= NULL
);
924 gdb_assert (selector
!= NULL
);
928 s1
= skip_spaces (s1
);
934 s1
= skip_spaces (s1
);
936 if ((s1
[0] == '+') || (s1
[0] == '-'))
939 s1
= skip_spaces (s1
);
946 while (isalnum (*s1
) || (*s1
== '_'))
950 s2
= skip_spaces (s2
);
955 s2
= skip_spaces (s2
);
957 while (isalnum (*s2
) || (*s2
== '_'))
962 /* Truncate the class name now that we're not using the open paren. */
970 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
972 else if (isspace (*s2
))
983 s2
= skip_spaces (s2
);
989 s2
= skip_spaces (s2
);
994 if (theclass
!= NULL
)
996 if (category
!= NULL
)
997 *category
= ncategory
;
998 if (selector
!= NULL
)
999 *selector
= nselector
;
1005 find_methods (char type
, const char *theclass
, const char *category
,
1006 const char *selector
,
1007 std::vector
<const char *> *symbol_names
)
1009 const char *symname
= NULL
;
1012 char *nclass
= NULL
;
1013 char *ncategory
= NULL
;
1014 char *nselector
= NULL
;
1016 static char *tmp
= NULL
;
1017 static unsigned int tmplen
= 0;
1019 gdb_assert (symbol_names
!= NULL
);
1021 for (objfile
*objfile
: current_program_space
->objfiles ())
1023 unsigned int *objc_csym
;
1025 /* The objfile_csym variable counts the number of ObjC methods
1026 that this objfile defines. We save that count as a private
1027 objfile data. If we have already determined that this objfile
1028 provides no ObjC methods, we can skip it entirely. */
1030 unsigned int objfile_csym
= 0;
1032 objc_csym
= objc_objfile_data
.get (objfile
);
1033 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1034 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1037 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1041 /* Check the symbol name first as this can be done entirely without
1042 sending any query to the target. */
1043 symname
= msymbol
->natural_name ();
1044 if (symname
== NULL
)
1047 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1048 /* Not a method name. */
1053 /* Now that thinks are a bit sane, clean up the symname. */
1054 while ((strlen (symname
) + 1) >= tmplen
)
1056 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1057 tmp
= (char *) xrealloc (tmp
, tmplen
);
1059 strcpy (tmp
, symname
);
1061 if (parse_method (tmp
, &ntype
, &nclass
,
1062 &ncategory
, &nselector
) == NULL
)
1065 if ((type
!= '\0') && (ntype
!= type
))
1068 if ((theclass
!= NULL
)
1069 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1072 if ((category
!= NULL
) &&
1073 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1076 if ((selector
!= NULL
) &&
1077 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1080 symbol_names
->push_back (symname
);
1083 if (objc_csym
== NULL
)
1084 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1086 /* Count of ObjC methods in this objfile should be constant. */
1087 gdb_assert (*objc_csym
== objfile_csym
);
1091 /* Uniquify a vector of strings. */
1094 uniquify_strings (std::vector
<const char *> *strings
)
1096 if (strings
->empty ())
1099 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1100 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1105 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1107 * Input: a string representing a selector
1108 * a pointer to an array of symbol pointers
1109 * possibly a pointer to a symbol found by the caller.
1111 * Output: number of methods that implement that selector. Side
1112 * effects: The array of symbol pointers is filled with matching syms.
1114 * By analogy with function "find_methods" (symtab.c), builds a list
1115 * of symbols matching the ambiguous input, so that "decode_line_2"
1116 * (symtab.c) can list them and ask the user to choose one or more.
1117 * In this case the matches are objective c methods
1118 * ("implementations") matching an objective c selector.
1120 * Note that it is possible for a normal (c-style) function to have
1121 * the same name as an objective c selector. To prevent the selector
1122 * from eclipsing the function, we allow the caller (decode_line_1) to
1123 * search for such a function first, and if it finds one, pass it in
1124 * to us. We will then integrate it into the list. We also search
1125 * for one here, among the minsyms.
1127 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1128 * into two parts: debuggable (struct symbol) syms, and
1129 * non_debuggable (struct minimal_symbol) syms. The debuggable
1130 * ones will come first, before NUM_DEBUGGABLE (which will thus
1131 * be the index of the first non-debuggable one).
1135 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1138 char *theclass
= NULL
;
1139 char *category
= NULL
;
1140 char *selector
= NULL
;
1145 int selector_case
= 0;
1147 gdb_assert (symbol_names
!= NULL
);
1149 buf
= (char *) alloca (strlen (method
) + 1);
1150 strcpy (buf
, method
);
1151 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1155 strcpy (buf
, method
);
1156 tmp
= parse_selector (buf
, &selector
);
1164 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1166 /* If we hit the "selector" case, and we found some methods, then
1167 add the selector itself as a symbol, if it exists. */
1168 if (selector_case
&& !symbol_names
->empty ())
1170 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1174 symbol_names
->push_back (sym
->natural_name ());
1177 struct bound_minimal_symbol msym
1178 = lookup_minimal_symbol (selector
, 0, 0);
1180 if (msym
.minsym
!= NULL
)
1181 symbol_names
->push_back (msym
.minsym
->natural_name ());
1185 uniquify_strings (symbol_names
);
1187 return method
+ (tmp
- buf
);
1191 print_object_command (const char *args
, int from_tty
)
1193 struct value
*object
, *function
, *description
;
1194 CORE_ADDR string_addr
, object_addr
;
1198 if (!args
|| !*args
)
1200 "The 'print-object' command requires an argument (an Objective-C object)");
1203 expression_up expr
= parse_expression (args
);
1206 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1207 expr
.get (), &pc
, EVAL_NORMAL
);
1210 /* Validate the address for sanity. */
1211 object_addr
= value_as_long (object
);
1212 read_memory (object_addr
, &c
, 1);
1214 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1215 if (function
== NULL
)
1216 error (_("Unable to locate _NSPrintForDebugger in child process"));
1218 description
= call_function_by_hand (function
, NULL
, object
);
1220 string_addr
= value_as_long (description
);
1221 if (string_addr
== 0)
1222 error (_("object returns null description"));
1224 read_memory (string_addr
+ i
++, &c
, 1);
1227 { /* Read and print characters up to EOS. */
1229 printf_filtered ("%c", c
);
1230 read_memory (string_addr
+ i
++, &c
, 1);
1233 printf_filtered(_("<object returns empty description>"));
1234 printf_filtered ("\n");
1237 /* The data structure 'methcalls' is used to detect method calls (thru
1238 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1239 * and ultimately find the method being called.
1242 struct objc_methcall
{
1244 /* Return instance method to be called. */
1245 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1246 /* Start of pc range corresponding to method invocation. */
1248 /* End of pc range corresponding to method invocation. */
1252 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1253 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1254 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1255 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1257 static struct objc_methcall methcalls
[] = {
1258 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1259 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1260 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1261 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1262 { "_objc_getClass", NULL
, 0, 0},
1263 { "_objc_getMetaClass", NULL
, 0, 0}
1266 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1268 /* The following function, "find_objc_msgsend", fills in the data
1269 * structure "objc_msgs" by finding the addresses of each of the
1270 * (currently four) functions that it holds (of which objc_msgSend is
1271 * the first). This must be called each time symbols are loaded, in
1272 * case the functions have moved for some reason.
1276 find_objc_msgsend (void)
1280 for (i
= 0; i
< nmethcalls
; i
++)
1282 struct bound_minimal_symbol func
;
1284 /* Try both with and without underscore. */
1285 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1286 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1288 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1290 if (func
.minsym
== NULL
)
1292 methcalls
[i
].begin
= 0;
1293 methcalls
[i
].end
= 0;
1297 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1298 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1302 /* find_objc_msgcall (replaces pc_off_limits)
1304 * ALL that this function now does is to determine whether the input
1305 * address ("pc") is the address of one of the Objective-C message
1306 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1307 * if so, it returns the address of the method that will be called.
1309 * The old function "pc_off_limits" used to do a lot of other things
1310 * in addition, such as detecting shared library jump stubs and
1311 * returning the address of the shlib function that would be called.
1312 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1313 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1314 * dependent modules.
1318 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1324 if (f (pc
, new_pc
) == 0)
1327 catch (const gdb_exception
&ex
)
1329 exception_fprintf (gdb_stderr
, ex
,
1330 "Unable to determine target of "
1331 "Objective-C method call (ignoring):\n");
1338 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1342 find_objc_msgsend ();
1348 for (i
= 0; i
< nmethcalls
; i
++)
1349 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1351 if (methcalls
[i
].stop_at
!= NULL
)
1352 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1361 void _initialize_objc_language ();
1363 _initialize_objc_language ()
1365 add_info ("selectors", info_selectors_command
,
1366 _("All Objective-C selectors, or those matching REGEXP."));
1367 add_info ("classes", info_classes_command
,
1368 _("All Objective-C classes, or those matching REGEXP."));
1369 add_com ("print-object", class_vars
, print_object_command
,
1370 _("Ask an Objective-C object to print itself."));
1371 add_com_alias ("po", "print-object", class_vars
, 1);
1375 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1376 struct objc_method
*method
)
1378 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1380 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1381 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1382 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1385 static unsigned long
1386 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1388 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1390 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1394 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1395 unsigned long num
, struct objc_method
*method
)
1397 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1398 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1402 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1403 struct objc_object
*object
)
1405 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1407 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1411 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1412 struct objc_super
*super
)
1414 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1416 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1417 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1421 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1422 struct objc_class
*theclass
)
1424 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1426 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1427 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1428 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1429 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1430 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1431 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1433 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1434 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1435 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1436 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1440 find_implementation_from_class (struct gdbarch
*gdbarch
,
1441 CORE_ADDR theclass
, CORE_ADDR sel
)
1443 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1444 CORE_ADDR subclass
= theclass
;
1446 while (subclass
!= 0)
1449 struct objc_class class_str
;
1450 unsigned mlistnum
= 0;
1452 read_objc_class (gdbarch
, subclass
, &class_str
);
1457 unsigned long nmethods
;
1460 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1466 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1468 for (i
= 0; i
< nmethods
; i
++)
1470 struct objc_method meth_str
;
1472 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1474 if (meth_str
.name
== sel
)
1475 /* FIXME: hppa arch was doing a pointer dereference
1476 here. There needs to be a better way to do that. */
1477 return meth_str
.imp
;
1481 subclass
= class_str
.super_class
;
1488 find_implementation (struct gdbarch
*gdbarch
,
1489 CORE_ADDR object
, CORE_ADDR sel
)
1491 struct objc_object ostr
;
1495 read_objc_object (gdbarch
, object
, &ostr
);
1499 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1503 resolve_msgsend (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
;
1513 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1514 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1516 res
= find_implementation (gdbarch
, object
, sel
);
1525 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1527 struct frame_info
*frame
= get_current_frame ();
1528 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1529 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1535 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1536 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1538 res
= find_implementation (gdbarch
, object
, sel
);
1547 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1549 struct frame_info
*frame
= get_current_frame ();
1550 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1551 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1553 struct objc_super sstr
;
1559 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1560 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1562 read_objc_super (gdbarch
, super
, &sstr
);
1563 if (sstr
.theclass
== 0)
1566 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1575 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1577 struct frame_info
*frame
= get_current_frame ();
1578 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1579 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1581 struct objc_super sstr
;
1587 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1588 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1590 read_objc_super (gdbarch
, super
, &sstr
);
1591 if (sstr
.theclass
== 0)
1594 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);