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. */
284 /* Determine if we are currently in the Objective-C dispatch function.
285 If so, get the address of the method function that the dispatcher
286 would call and use that as the function to step into instead. Also
287 skip over the trampoline for the function (if any). This is better
288 for the user since they are only interested in stepping into the
289 method function anyway. */
291 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
293 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
294 CORE_ADDR real_stop_pc
;
295 CORE_ADDR method_stop_pc
;
297 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
299 if (real_stop_pc
!= 0)
300 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
302 find_objc_msgcall (stop_pc
, &method_stop_pc
);
306 real_stop_pc
= gdbarch_skip_trampoline_code
307 (gdbarch
, frame
, method_stop_pc
);
308 if (real_stop_pc
== 0)
309 real_stop_pc
= method_stop_pc
;
316 /* Table mapping opcodes into strings for printing operators
317 and precedences of the operators. */
319 static const struct op_print objc_op_print_tab
[] =
321 {",", BINOP_COMMA
, PREC_COMMA
, 0},
322 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
323 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
324 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
325 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
326 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
327 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
328 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
329 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
330 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
331 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
332 {">", BINOP_GTR
, PREC_ORDER
, 0},
333 {"<", BINOP_LESS
, PREC_ORDER
, 0},
334 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
335 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
336 {"+", BINOP_ADD
, PREC_ADD
, 0},
337 {"-", BINOP_SUB
, PREC_ADD
, 0},
338 {"*", BINOP_MUL
, PREC_MUL
, 0},
339 {"/", BINOP_DIV
, PREC_MUL
, 0},
340 {"%", BINOP_REM
, PREC_MUL
, 0},
341 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
342 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
343 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
344 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
345 {"*", UNOP_IND
, PREC_PREFIX
, 0},
346 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
347 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
348 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
349 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
350 {NULL
, OP_NULL
, PREC_NULL
, 0}
353 static const char *objc_extensions
[] =
358 /* Constant data representing the Objective-C language. */
360 extern const struct language_data objc_language_data
=
362 "objective-c", /* Language name */
370 &exp_descriptor_standard
,
373 c_printchar
, /* Print a character constant */
374 c_printstr
, /* Function to print string constant */
376 c_print_type
, /* Print a type using appropriate syntax */
377 c_print_typedef
, /* Print a typedef using appropriate syntax */
378 c_value_print_inner
, /* la_value_print_inner */
379 c_value_print
, /* Print a top-level value */
380 objc_skip_trampoline
, /* Language specific skip_trampoline */
381 "self", /* name_of_this */
382 false, /* la_store_sym_names_in_linkage_form_p */
383 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
384 objc_demangle
, /* Language specific symbol demangler */
385 NULL
, /* Language specific
386 class_name_from_physname */
387 objc_op_print_tab
, /* Expression operators for printing */
388 1, /* C-style arrays */
389 0, /* String lower bound */
390 default_word_break_characters
,
391 default_collect_symbol_completion_matches
,
392 c_watch_location_expression
,
393 NULL
, /* la_get_symbol_name_matcher */
397 "{...}" /* la_struct_too_deep_ellipsis */
400 /* Class representing the Objective-C language. */
402 class objc_language
: public language_defn
406 : language_defn (language_objc
, objc_language_data
)
409 /* See language.h. */
410 void language_arch_info (struct gdbarch
*gdbarch
,
411 struct language_arch_info
*lai
) const override
413 c_language_arch_info (gdbarch
, lai
);
416 /* See language.h. */
417 bool sniff_from_mangled_name (const char *mangled
,
418 char **demangled
) const override
420 *demangled
= objc_demangle (mangled
, 0);
421 return *demangled
!= NULL
;
425 /* Single instance of the class representing the Objective-C language. */
427 static objc_language objc_language_defn
;
431 * Following functions help construct Objective-C message calls.
434 struct selname
/* For parsing Objective-C. */
436 struct selname
*next
;
441 static int msglist_len
;
442 static struct selname
*selname_chain
;
443 static char *msglist_sel
;
448 struct selname
*newobj
= XNEW (struct selname
);
450 newobj
->next
= selname_chain
;
451 newobj
->msglist_len
= msglist_len
;
452 newobj
->msglist_sel
= msglist_sel
;
454 msglist_sel
= (char *)xmalloc(1);
456 selname_chain
= newobj
;
460 add_msglist(struct stoken
*str
, int addcolon
)
466 if (str
== 0) /* Unnamed arg, or... */
468 if (addcolon
== 0) /* variable number of args. */
481 len
= plen
+ strlen(msglist_sel
) + 2;
482 s
= (char *)xmalloc(len
);
483 strcpy(s
, msglist_sel
);
498 end_msglist (struct parser_state
*ps
)
500 int val
= msglist_len
;
501 struct selname
*sel
= selname_chain
;
502 char *p
= msglist_sel
;
505 selname_chain
= sel
->next
;
506 msglist_len
= sel
->msglist_len
;
507 msglist_sel
= sel
->msglist_sel
;
508 selid
= lookup_child_selector (ps
->gdbarch (), p
);
510 error (_("Can't find selector \"%s\""), p
);
511 write_exp_elt_longcst (ps
, selid
);
513 write_exp_elt_longcst (ps
, val
); /* Number of args */
520 * Function: specialcmp (const char *a, const char *b)
522 * Special strcmp: treats ']' and ' ' as end-of-string.
523 * Used for qsorting lists of objc methods (either by class or selector).
527 specialcmp (const char *a
, const char *b
)
529 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
535 if (*a
&& *a
!= ' ' && *a
!= ']')
536 return 1; /* a is longer therefore greater. */
537 if (*b
&& *b
!= ' ' && *b
!= ']')
538 return -1; /* a is shorter therefore lesser. */
539 return 0; /* a and b are identical. */
543 * Function: compare_selectors (const void *, const void *)
545 * Comparison function for use with qsort. Arguments are symbols or
546 * msymbols Compares selector part of objc method name alphabetically.
550 compare_selectors (const void *a
, const void *b
)
552 const char *aname
, *bname
;
554 aname
= (*(struct symbol
**) a
)->print_name ();
555 bname
= (*(struct symbol
**) b
)->print_name ();
556 if (aname
== NULL
|| bname
== NULL
)
557 error (_("internal: compare_selectors(1)"));
559 aname
= strchr(aname
, ' ');
560 bname
= strchr(bname
, ' ');
561 if (aname
== NULL
|| bname
== NULL
)
562 error (_("internal: compare_selectors(2)"));
564 return specialcmp (aname
+1, bname
+1);
568 * Function: selectors_info (regexp, from_tty)
570 * Implements the "Info selectors" command. Takes an optional regexp
571 * arg. Lists all objective c selectors that match the regexp. Works
572 * by grepping thru all symbols for objective c methods. Output list
573 * is sorted and uniqued.
577 info_selectors_command (const char *regexp
, int from_tty
)
586 struct symbol
**sym_arr
;
590 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
593 if (*regexp
== '+' || *regexp
== '-')
594 { /* User wants only class methods or only instance methods. */
595 plusminus
= *regexp
++;
596 while (*regexp
== ' ' || *regexp
== '\t')
600 strcpy(myregexp
, ".*]");
603 /* Allow a few extra bytes because of the strcat below. */
604 if (sizeof (myregexp
) < strlen (regexp
) + 4)
605 error (_("Regexp is too long: %s"), regexp
);
606 strcpy(myregexp
, regexp
);
607 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
608 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
610 strcat(myregexp
, ".*]");
616 val
= re_comp (myregexp
);
618 error (_("Invalid regexp (%s): %s"), val
, regexp
);
621 /* First time thru is JUST to get max length and count. */
622 for (objfile
*objfile
: current_program_space
->objfiles ())
624 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
627 name
= msymbol
->natural_name ();
629 && (name
[0] == '-' || name
[0] == '+')
630 && name
[1] == '[') /* Got a method name. */
632 /* Filter for class/instance methods. */
633 if (plusminus
&& name
[0] != plusminus
)
635 /* Find selector part. */
636 name
= (char *) strchr (name
+2, ' ');
639 complaint (_("Bad method name '%s'"),
640 msymbol
->natural_name ());
643 if (regexp
== NULL
|| re_exec(++name
) != 0)
645 const char *mystart
= name
;
646 const char *myend
= strchr (mystart
, ']');
648 if (myend
&& (myend
- mystart
> maxlen
))
649 maxlen
= myend
- mystart
; /* Get longest selector. */
657 printf_filtered (_("Selectors matching \"%s\":\n\n"),
658 regexp
? regexp
: "*");
660 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
662 for (objfile
*objfile
: current_program_space
->objfiles ())
664 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
667 name
= msymbol
->natural_name ();
669 (name
[0] == '-' || name
[0] == '+') &&
670 name
[1] == '[') /* Got a method name. */
672 /* Filter for class/instance methods. */
673 if (plusminus
&& name
[0] != plusminus
)
675 /* Find selector part. */
676 name
= (char *) strchr(name
+2, ' ');
677 if (regexp
== NULL
|| re_exec(++name
) != 0)
678 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
683 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
685 /* Prevent compare on first iteration. */
687 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
692 name
= sym_arr
[ix
]->natural_name ();
693 name
= strchr (name
, ' ') + 1;
694 if (p
[0] && specialcmp(name
, p
) == 0)
695 continue; /* Seen this one already (not unique). */
697 /* Copy selector part. */
698 while (*name
&& *name
!= ']')
701 /* Print in columns. */
702 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
707 printf_filtered (_("No selectors matching \"%s\"\n"),
708 regexp
? regexp
: "*");
712 * Function: compare_classes (const void *, const void *)
714 * Comparison function for use with qsort. Arguments are symbols or
715 * msymbols Compares class part of objc method name alphabetically.
719 compare_classes (const void *a
, const void *b
)
721 const char *aname
, *bname
;
723 aname
= (*(struct symbol
**) a
)->print_name ();
724 bname
= (*(struct symbol
**) b
)->print_name ();
725 if (aname
== NULL
|| bname
== NULL
)
726 error (_("internal: compare_classes(1)"));
728 return specialcmp (aname
+1, bname
+1);
732 * Function: classes_info(regexp, from_tty)
734 * Implements the "info classes" command for objective c classes.
735 * Lists all objective c classes that match the optional regexp.
736 * Works by grepping thru the list of objective c methods. List will
737 * be sorted and uniqued (since one class may have many methods).
738 * BUGS: will not list a class that has no methods.
742 info_classes_command (const char *regexp
, int from_tty
)
751 struct symbol
**sym_arr
;
754 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
757 /* Allow a few extra bytes because of the strcat below. */
758 if (sizeof (myregexp
) < strlen (regexp
) + 4)
759 error (_("Regexp is too long: %s"), regexp
);
760 strcpy(myregexp
, regexp
);
761 if (myregexp
[strlen(myregexp
) - 1] == '$')
762 /* In the method name, the end of the class name is marked by ' '. */
763 myregexp
[strlen(myregexp
) - 1] = ' ';
765 strcat(myregexp
, ".* ");
770 val
= re_comp (myregexp
);
772 error (_("Invalid regexp (%s): %s"), val
, regexp
);
775 /* First time thru is JUST to get max length and count. */
776 for (objfile
*objfile
: current_program_space
->objfiles ())
778 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
781 name
= msymbol
->natural_name ();
783 (name
[0] == '-' || name
[0] == '+') &&
784 name
[1] == '[') /* Got a method name. */
785 if (regexp
== NULL
|| re_exec(name
+2) != 0)
787 /* Compute length of classname part. */
788 const char *mystart
= name
+ 2;
789 const char *myend
= strchr (mystart
, ' ');
791 if (myend
&& (myend
- mystart
> maxlen
))
792 maxlen
= myend
- mystart
;
799 printf_filtered (_("Classes matching \"%s\":\n\n"),
800 regexp
? regexp
: "*");
801 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
803 for (objfile
*objfile
: current_program_space
->objfiles ())
805 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
808 name
= msymbol
->natural_name ();
810 (name
[0] == '-' || name
[0] == '+') &&
811 name
[1] == '[') /* Got a method name. */
812 if (regexp
== NULL
|| re_exec(name
+2) != 0)
813 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
817 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
819 /* Prevent compare on first iteration. */
821 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
826 name
= sym_arr
[ix
]->natural_name ();
828 if (p
[0] && specialcmp(name
, p
) == 0)
829 continue; /* Seen this one already (not unique). */
831 /* Copy class part of method name. */
832 while (*name
&& *name
!= ' ')
835 /* Print in columns. */
836 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
841 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
845 parse_selector (char *method
, char **selector
)
851 char *nselector
= NULL
;
853 gdb_assert (selector
!= NULL
);
857 s1
= skip_spaces (s1
);
863 s1
= skip_spaces (s1
);
870 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
872 else if (isspace (*s2
))
874 else if ((*s2
== '\0') || (*s2
== '\''))
882 s2
= skip_spaces (s2
);
887 s2
= skip_spaces (s2
);
890 if (selector
!= NULL
)
891 *selector
= nselector
;
897 parse_method (char *method
, char *type
, char **theclass
,
898 char **category
, char **selector
)
906 char *ncategory
= NULL
;
907 char *nselector
= NULL
;
909 gdb_assert (type
!= NULL
);
910 gdb_assert (theclass
!= NULL
);
911 gdb_assert (category
!= NULL
);
912 gdb_assert (selector
!= NULL
);
916 s1
= skip_spaces (s1
);
922 s1
= skip_spaces (s1
);
924 if ((s1
[0] == '+') || (s1
[0] == '-'))
927 s1
= skip_spaces (s1
);
934 while (isalnum (*s1
) || (*s1
== '_'))
938 s2
= skip_spaces (s2
);
943 s2
= skip_spaces (s2
);
945 while (isalnum (*s2
) || (*s2
== '_'))
950 /* Truncate the class name now that we're not using the open paren. */
958 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
960 else if (isspace (*s2
))
971 s2
= skip_spaces (s2
);
977 s2
= skip_spaces (s2
);
982 if (theclass
!= NULL
)
984 if (category
!= NULL
)
985 *category
= ncategory
;
986 if (selector
!= NULL
)
987 *selector
= nselector
;
993 find_methods (char type
, const char *theclass
, const char *category
,
994 const char *selector
,
995 std::vector
<const char *> *symbol_names
)
997 const char *symname
= NULL
;
1000 char *nclass
= NULL
;
1001 char *ncategory
= NULL
;
1002 char *nselector
= NULL
;
1004 static char *tmp
= NULL
;
1005 static unsigned int tmplen
= 0;
1007 gdb_assert (symbol_names
!= NULL
);
1009 for (objfile
*objfile
: current_program_space
->objfiles ())
1011 unsigned int *objc_csym
;
1013 /* The objfile_csym variable counts the number of ObjC methods
1014 that this objfile defines. We save that count as a private
1015 objfile data. If we have already determined that this objfile
1016 provides no ObjC methods, we can skip it entirely. */
1018 unsigned int objfile_csym
= 0;
1020 objc_csym
= objc_objfile_data
.get (objfile
);
1021 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1022 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1025 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1029 /* Check the symbol name first as this can be done entirely without
1030 sending any query to the target. */
1031 symname
= msymbol
->natural_name ();
1032 if (symname
== NULL
)
1035 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1036 /* Not a method name. */
1041 /* Now that thinks are a bit sane, clean up the symname. */
1042 while ((strlen (symname
) + 1) >= tmplen
)
1044 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1045 tmp
= (char *) xrealloc (tmp
, tmplen
);
1047 strcpy (tmp
, symname
);
1049 if (parse_method (tmp
, &ntype
, &nclass
,
1050 &ncategory
, &nselector
) == NULL
)
1053 if ((type
!= '\0') && (ntype
!= type
))
1056 if ((theclass
!= NULL
)
1057 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1060 if ((category
!= NULL
) &&
1061 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1064 if ((selector
!= NULL
) &&
1065 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1068 symbol_names
->push_back (symname
);
1071 if (objc_csym
== NULL
)
1072 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1074 /* Count of ObjC methods in this objfile should be constant. */
1075 gdb_assert (*objc_csym
== objfile_csym
);
1079 /* Uniquify a vector of strings. */
1082 uniquify_strings (std::vector
<const char *> *strings
)
1084 if (strings
->empty ())
1087 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1088 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1093 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1095 * Input: a string representing a selector
1096 * a pointer to an array of symbol pointers
1097 * possibly a pointer to a symbol found by the caller.
1099 * Output: number of methods that implement that selector. Side
1100 * effects: The array of symbol pointers is filled with matching syms.
1102 * By analogy with function "find_methods" (symtab.c), builds a list
1103 * of symbols matching the ambiguous input, so that "decode_line_2"
1104 * (symtab.c) can list them and ask the user to choose one or more.
1105 * In this case the matches are objective c methods
1106 * ("implementations") matching an objective c selector.
1108 * Note that it is possible for a normal (c-style) function to have
1109 * the same name as an objective c selector. To prevent the selector
1110 * from eclipsing the function, we allow the caller (decode_line_1) to
1111 * search for such a function first, and if it finds one, pass it in
1112 * to us. We will then integrate it into the list. We also search
1113 * for one here, among the minsyms.
1115 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1116 * into two parts: debuggable (struct symbol) syms, and
1117 * non_debuggable (struct minimal_symbol) syms. The debuggable
1118 * ones will come first, before NUM_DEBUGGABLE (which will thus
1119 * be the index of the first non-debuggable one).
1123 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1126 char *theclass
= NULL
;
1127 char *category
= NULL
;
1128 char *selector
= NULL
;
1133 int selector_case
= 0;
1135 gdb_assert (symbol_names
!= NULL
);
1137 buf
= (char *) alloca (strlen (method
) + 1);
1138 strcpy (buf
, method
);
1139 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1143 strcpy (buf
, method
);
1144 tmp
= parse_selector (buf
, &selector
);
1152 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1154 /* If we hit the "selector" case, and we found some methods, then
1155 add the selector itself as a symbol, if it exists. */
1156 if (selector_case
&& !symbol_names
->empty ())
1158 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1162 symbol_names
->push_back (sym
->natural_name ());
1165 struct bound_minimal_symbol msym
1166 = lookup_minimal_symbol (selector
, 0, 0);
1168 if (msym
.minsym
!= NULL
)
1169 symbol_names
->push_back (msym
.minsym
->natural_name ());
1173 uniquify_strings (symbol_names
);
1175 return method
+ (tmp
- buf
);
1179 print_object_command (const char *args
, int from_tty
)
1181 struct value
*object
, *function
, *description
;
1182 CORE_ADDR string_addr
, object_addr
;
1186 if (!args
|| !*args
)
1188 "The 'print-object' command requires an argument (an Objective-C object)");
1191 expression_up expr
= parse_expression (args
);
1194 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1195 expr
.get (), &pc
, EVAL_NORMAL
);
1198 /* Validate the address for sanity. */
1199 object_addr
= value_as_long (object
);
1200 read_memory (object_addr
, &c
, 1);
1202 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1203 if (function
== NULL
)
1204 error (_("Unable to locate _NSPrintForDebugger in child process"));
1206 description
= call_function_by_hand (function
, NULL
, object
);
1208 string_addr
= value_as_long (description
);
1209 if (string_addr
== 0)
1210 error (_("object returns null description"));
1212 read_memory (string_addr
+ i
++, &c
, 1);
1215 { /* Read and print characters up to EOS. */
1217 printf_filtered ("%c", c
);
1218 read_memory (string_addr
+ i
++, &c
, 1);
1221 printf_filtered(_("<object returns empty description>"));
1222 printf_filtered ("\n");
1225 /* The data structure 'methcalls' is used to detect method calls (thru
1226 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1227 * and ultimately find the method being called.
1230 struct objc_methcall
{
1232 /* Return instance method to be called. */
1233 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1234 /* Start of pc range corresponding to method invocation. */
1236 /* End of pc range corresponding to method invocation. */
1240 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1241 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1242 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1243 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1245 static struct objc_methcall methcalls
[] = {
1246 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1247 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1248 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1249 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1250 { "_objc_getClass", NULL
, 0, 0},
1251 { "_objc_getMetaClass", NULL
, 0, 0}
1254 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1256 /* The following function, "find_objc_msgsend", fills in the data
1257 * structure "objc_msgs" by finding the addresses of each of the
1258 * (currently four) functions that it holds (of which objc_msgSend is
1259 * the first). This must be called each time symbols are loaded, in
1260 * case the functions have moved for some reason.
1264 find_objc_msgsend (void)
1268 for (i
= 0; i
< nmethcalls
; i
++)
1270 struct bound_minimal_symbol func
;
1272 /* Try both with and without underscore. */
1273 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1274 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1276 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1278 if (func
.minsym
== NULL
)
1280 methcalls
[i
].begin
= 0;
1281 methcalls
[i
].end
= 0;
1285 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1286 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1290 /* find_objc_msgcall (replaces pc_off_limits)
1292 * ALL that this function now does is to determine whether the input
1293 * address ("pc") is the address of one of the Objective-C message
1294 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1295 * if so, it returns the address of the method that will be called.
1297 * The old function "pc_off_limits" used to do a lot of other things
1298 * in addition, such as detecting shared library jump stubs and
1299 * returning the address of the shlib function that would be called.
1300 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1301 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1302 * dependent modules.
1306 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1312 if (f (pc
, new_pc
) == 0)
1315 catch (const gdb_exception
&ex
)
1317 exception_fprintf (gdb_stderr
, ex
,
1318 "Unable to determine target of "
1319 "Objective-C method call (ignoring):\n");
1326 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1330 find_objc_msgsend ();
1336 for (i
= 0; i
< nmethcalls
; i
++)
1337 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1339 if (methcalls
[i
].stop_at
!= NULL
)
1340 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1349 void _initialize_objc_language ();
1351 _initialize_objc_language ()
1353 add_info ("selectors", info_selectors_command
,
1354 _("All Objective-C selectors, or those matching REGEXP."));
1355 add_info ("classes", info_classes_command
,
1356 _("All Objective-C classes, or those matching REGEXP."));
1357 add_com ("print-object", class_vars
, print_object_command
,
1358 _("Ask an Objective-C object to print itself."));
1359 add_com_alias ("po", "print-object", class_vars
, 1);
1363 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1364 struct objc_method
*method
)
1366 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1368 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1369 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1370 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1373 static unsigned long
1374 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1376 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1378 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1382 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1383 unsigned long num
, struct objc_method
*method
)
1385 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1386 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1390 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1391 struct objc_object
*object
)
1393 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1395 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1399 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1400 struct objc_super
*super
)
1402 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1404 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1405 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1409 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1410 struct objc_class
*theclass
)
1412 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1414 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1415 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1416 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1417 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1418 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1419 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1421 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1422 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1423 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1424 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1428 find_implementation_from_class (struct gdbarch
*gdbarch
,
1429 CORE_ADDR theclass
, CORE_ADDR sel
)
1431 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1432 CORE_ADDR subclass
= theclass
;
1434 while (subclass
!= 0)
1437 struct objc_class class_str
;
1438 unsigned mlistnum
= 0;
1440 read_objc_class (gdbarch
, subclass
, &class_str
);
1445 unsigned long nmethods
;
1448 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1454 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1456 for (i
= 0; i
< nmethods
; i
++)
1458 struct objc_method meth_str
;
1460 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1462 if (meth_str
.name
== sel
)
1463 /* FIXME: hppa arch was doing a pointer dereference
1464 here. There needs to be a better way to do that. */
1465 return meth_str
.imp
;
1469 subclass
= class_str
.super_class
;
1476 find_implementation (struct gdbarch
*gdbarch
,
1477 CORE_ADDR object
, CORE_ADDR sel
)
1479 struct objc_object ostr
;
1483 read_objc_object (gdbarch
, object
, &ostr
);
1487 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1491 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1493 struct frame_info
*frame
= get_current_frame ();
1494 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1495 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1501 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1502 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1504 res
= find_implementation (gdbarch
, object
, sel
);
1513 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1515 struct frame_info
*frame
= get_current_frame ();
1516 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1517 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1523 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1524 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1526 res
= find_implementation (gdbarch
, object
, sel
);
1535 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1537 struct frame_info
*frame
= get_current_frame ();
1538 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1539 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1541 struct objc_super sstr
;
1547 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1548 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1550 read_objc_super (gdbarch
, super
, &sstr
);
1551 if (sstr
.theclass
== 0)
1554 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1563 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1565 struct frame_info
*frame
= get_current_frame ();
1566 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1567 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1569 struct objc_super sstr
;
1575 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1576 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1578 read_objc_super (gdbarch
, super
, &sstr
);
1579 if (sstr
.theclass
== 0)
1582 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);