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 */
356 "{...}" /* la_struct_too_deep_ellipsis */
359 /* Class representing the Objective-C language. */
361 class objc_language
: public language_defn
365 : language_defn (language_objc
, objc_language_data
)
368 /* See language.h. */
369 void language_arch_info (struct gdbarch
*gdbarch
,
370 struct language_arch_info
*lai
) const override
372 c_language_arch_info (gdbarch
, lai
);
375 /* See language.h. */
376 bool sniff_from_mangled_name (const char *mangled
,
377 char **demangled
) const override
379 *demangled
= objc_demangle (mangled
, 0);
380 return *demangled
!= NULL
;
383 /* See language.h. */
385 char *demangle (const char *mangled
, int options
) const override
387 return objc_demangle (mangled
, options
);
390 /* See language.h. */
392 void print_type (struct type
*type
, const char *varstring
,
393 struct ui_file
*stream
, int show
, int level
,
394 const struct type_print_options
*flags
) const override
396 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
399 /* See language.h. */
401 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
402 CORE_ADDR stop_pc
) const override
404 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
405 CORE_ADDR real_stop_pc
;
406 CORE_ADDR method_stop_pc
;
408 /* Determine if we are currently in the Objective-C dispatch function.
409 If so, get the address of the method function that the dispatcher
410 would call and use that as the function to step into instead. Also
411 skip over the trampoline for the function (if any). This is better
412 for the user since they are only interested in stepping into the
413 method function anyway. */
415 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
417 if (real_stop_pc
!= 0)
418 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
420 find_objc_msgcall (stop_pc
, &method_stop_pc
);
424 real_stop_pc
= gdbarch_skip_trampoline_code
425 (gdbarch
, frame
, method_stop_pc
);
426 if (real_stop_pc
== 0)
427 real_stop_pc
= method_stop_pc
;
434 /* Single instance of the class representing the Objective-C language. */
436 static objc_language objc_language_defn
;
440 * Following functions help construct Objective-C message calls.
443 struct selname
/* For parsing Objective-C. */
445 struct selname
*next
;
450 static int msglist_len
;
451 static struct selname
*selname_chain
;
452 static char *msglist_sel
;
457 struct selname
*newobj
= XNEW (struct selname
);
459 newobj
->next
= selname_chain
;
460 newobj
->msglist_len
= msglist_len
;
461 newobj
->msglist_sel
= msglist_sel
;
463 msglist_sel
= (char *)xmalloc(1);
465 selname_chain
= newobj
;
469 add_msglist(struct stoken
*str
, int addcolon
)
475 if (str
== 0) /* Unnamed arg, or... */
477 if (addcolon
== 0) /* variable number of args. */
490 len
= plen
+ strlen(msglist_sel
) + 2;
491 s
= (char *)xmalloc(len
);
492 strcpy(s
, msglist_sel
);
507 end_msglist (struct parser_state
*ps
)
509 int val
= msglist_len
;
510 struct selname
*sel
= selname_chain
;
511 char *p
= msglist_sel
;
514 selname_chain
= sel
->next
;
515 msglist_len
= sel
->msglist_len
;
516 msglist_sel
= sel
->msglist_sel
;
517 selid
= lookup_child_selector (ps
->gdbarch (), p
);
519 error (_("Can't find selector \"%s\""), p
);
520 write_exp_elt_longcst (ps
, selid
);
522 write_exp_elt_longcst (ps
, val
); /* Number of args */
529 * Function: specialcmp (const char *a, const char *b)
531 * Special strcmp: treats ']' and ' ' as end-of-string.
532 * Used for qsorting lists of objc methods (either by class or selector).
536 specialcmp (const char *a
, const char *b
)
538 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
544 if (*a
&& *a
!= ' ' && *a
!= ']')
545 return 1; /* a is longer therefore greater. */
546 if (*b
&& *b
!= ' ' && *b
!= ']')
547 return -1; /* a is shorter therefore lesser. */
548 return 0; /* a and b are identical. */
552 * Function: compare_selectors (const void *, const void *)
554 * Comparison function for use with qsort. Arguments are symbols or
555 * msymbols Compares selector part of objc method name alphabetically.
559 compare_selectors (const void *a
, const void *b
)
561 const char *aname
, *bname
;
563 aname
= (*(struct symbol
**) a
)->print_name ();
564 bname
= (*(struct symbol
**) b
)->print_name ();
565 if (aname
== NULL
|| bname
== NULL
)
566 error (_("internal: compare_selectors(1)"));
568 aname
= strchr(aname
, ' ');
569 bname
= strchr(bname
, ' ');
570 if (aname
== NULL
|| bname
== NULL
)
571 error (_("internal: compare_selectors(2)"));
573 return specialcmp (aname
+1, bname
+1);
577 * Function: selectors_info (regexp, from_tty)
579 * Implements the "Info selectors" command. Takes an optional regexp
580 * arg. Lists all objective c selectors that match the regexp. Works
581 * by grepping thru all symbols for objective c methods. Output list
582 * is sorted and uniqued.
586 info_selectors_command (const char *regexp
, int from_tty
)
595 struct symbol
**sym_arr
;
599 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
602 if (*regexp
== '+' || *regexp
== '-')
603 { /* User wants only class methods or only instance methods. */
604 plusminus
= *regexp
++;
605 while (*regexp
== ' ' || *regexp
== '\t')
609 strcpy(myregexp
, ".*]");
612 /* Allow a few extra bytes because of the strcat below. */
613 if (sizeof (myregexp
) < strlen (regexp
) + 4)
614 error (_("Regexp is too long: %s"), regexp
);
615 strcpy(myregexp
, regexp
);
616 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
617 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
619 strcat(myregexp
, ".*]");
625 val
= re_comp (myregexp
);
627 error (_("Invalid regexp (%s): %s"), val
, regexp
);
630 /* First time thru is JUST to get max length and count. */
631 for (objfile
*objfile
: current_program_space
->objfiles ())
633 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
636 name
= msymbol
->natural_name ();
638 && (name
[0] == '-' || name
[0] == '+')
639 && name
[1] == '[') /* Got a method name. */
641 /* Filter for class/instance methods. */
642 if (plusminus
&& name
[0] != plusminus
)
644 /* Find selector part. */
645 name
= (char *) strchr (name
+2, ' ');
648 complaint (_("Bad method name '%s'"),
649 msymbol
->natural_name ());
652 if (regexp
== NULL
|| re_exec(++name
) != 0)
654 const char *mystart
= name
;
655 const char *myend
= strchr (mystart
, ']');
657 if (myend
&& (myend
- mystart
> maxlen
))
658 maxlen
= myend
- mystart
; /* Get longest selector. */
666 printf_filtered (_("Selectors matching \"%s\":\n\n"),
667 regexp
? regexp
: "*");
669 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
671 for (objfile
*objfile
: current_program_space
->objfiles ())
673 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
676 name
= msymbol
->natural_name ();
678 (name
[0] == '-' || name
[0] == '+') &&
679 name
[1] == '[') /* Got a method name. */
681 /* Filter for class/instance methods. */
682 if (plusminus
&& name
[0] != plusminus
)
684 /* Find selector part. */
685 name
= (char *) strchr(name
+2, ' ');
686 if (regexp
== NULL
|| re_exec(++name
) != 0)
687 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
692 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
694 /* Prevent compare on first iteration. */
696 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
701 name
= sym_arr
[ix
]->natural_name ();
702 name
= strchr (name
, ' ') + 1;
703 if (p
[0] && specialcmp(name
, p
) == 0)
704 continue; /* Seen this one already (not unique). */
706 /* Copy selector part. */
707 while (*name
&& *name
!= ']')
710 /* Print in columns. */
711 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
716 printf_filtered (_("No selectors matching \"%s\"\n"),
717 regexp
? regexp
: "*");
721 * Function: compare_classes (const void *, const void *)
723 * Comparison function for use with qsort. Arguments are symbols or
724 * msymbols Compares class part of objc method name alphabetically.
728 compare_classes (const void *a
, const void *b
)
730 const char *aname
, *bname
;
732 aname
= (*(struct symbol
**) a
)->print_name ();
733 bname
= (*(struct symbol
**) b
)->print_name ();
734 if (aname
== NULL
|| bname
== NULL
)
735 error (_("internal: compare_classes(1)"));
737 return specialcmp (aname
+1, bname
+1);
741 * Function: classes_info(regexp, from_tty)
743 * Implements the "info classes" command for objective c classes.
744 * Lists all objective c classes that match the optional regexp.
745 * Works by grepping thru the list of objective c methods. List will
746 * be sorted and uniqued (since one class may have many methods).
747 * BUGS: will not list a class that has no methods.
751 info_classes_command (const char *regexp
, int from_tty
)
760 struct symbol
**sym_arr
;
763 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
766 /* Allow a few extra bytes because of the strcat below. */
767 if (sizeof (myregexp
) < strlen (regexp
) + 4)
768 error (_("Regexp is too long: %s"), regexp
);
769 strcpy(myregexp
, regexp
);
770 if (myregexp
[strlen(myregexp
) - 1] == '$')
771 /* In the method name, the end of the class name is marked by ' '. */
772 myregexp
[strlen(myregexp
) - 1] = ' ';
774 strcat(myregexp
, ".* ");
779 val
= re_comp (myregexp
);
781 error (_("Invalid regexp (%s): %s"), val
, regexp
);
784 /* First time thru is JUST to get max length and count. */
785 for (objfile
*objfile
: current_program_space
->objfiles ())
787 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
790 name
= msymbol
->natural_name ();
792 (name
[0] == '-' || name
[0] == '+') &&
793 name
[1] == '[') /* Got a method name. */
794 if (regexp
== NULL
|| re_exec(name
+2) != 0)
796 /* Compute length of classname part. */
797 const char *mystart
= name
+ 2;
798 const char *myend
= strchr (mystart
, ' ');
800 if (myend
&& (myend
- mystart
> maxlen
))
801 maxlen
= myend
- mystart
;
808 printf_filtered (_("Classes matching \"%s\":\n\n"),
809 regexp
? regexp
: "*");
810 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
812 for (objfile
*objfile
: current_program_space
->objfiles ())
814 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
817 name
= msymbol
->natural_name ();
819 (name
[0] == '-' || name
[0] == '+') &&
820 name
[1] == '[') /* Got a method name. */
821 if (regexp
== NULL
|| re_exec(name
+2) != 0)
822 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
826 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
828 /* Prevent compare on first iteration. */
830 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
835 name
= sym_arr
[ix
]->natural_name ();
837 if (p
[0] && specialcmp(name
, p
) == 0)
838 continue; /* Seen this one already (not unique). */
840 /* Copy class part of method name. */
841 while (*name
&& *name
!= ' ')
844 /* Print in columns. */
845 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
850 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
854 parse_selector (char *method
, char **selector
)
860 char *nselector
= NULL
;
862 gdb_assert (selector
!= NULL
);
866 s1
= skip_spaces (s1
);
872 s1
= skip_spaces (s1
);
879 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
881 else if (isspace (*s2
))
883 else if ((*s2
== '\0') || (*s2
== '\''))
891 s2
= skip_spaces (s2
);
896 s2
= skip_spaces (s2
);
899 if (selector
!= NULL
)
900 *selector
= nselector
;
906 parse_method (char *method
, char *type
, char **theclass
,
907 char **category
, char **selector
)
915 char *ncategory
= NULL
;
916 char *nselector
= NULL
;
918 gdb_assert (type
!= NULL
);
919 gdb_assert (theclass
!= NULL
);
920 gdb_assert (category
!= NULL
);
921 gdb_assert (selector
!= NULL
);
925 s1
= skip_spaces (s1
);
931 s1
= skip_spaces (s1
);
933 if ((s1
[0] == '+') || (s1
[0] == '-'))
936 s1
= skip_spaces (s1
);
943 while (isalnum (*s1
) || (*s1
== '_'))
947 s2
= skip_spaces (s2
);
952 s2
= skip_spaces (s2
);
954 while (isalnum (*s2
) || (*s2
== '_'))
959 /* Truncate the class name now that we're not using the open paren. */
967 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
969 else if (isspace (*s2
))
980 s2
= skip_spaces (s2
);
986 s2
= skip_spaces (s2
);
991 if (theclass
!= NULL
)
993 if (category
!= NULL
)
994 *category
= ncategory
;
995 if (selector
!= NULL
)
996 *selector
= nselector
;
1002 find_methods (char type
, const char *theclass
, const char *category
,
1003 const char *selector
,
1004 std::vector
<const char *> *symbol_names
)
1006 const char *symname
= NULL
;
1009 char *nclass
= NULL
;
1010 char *ncategory
= NULL
;
1011 char *nselector
= NULL
;
1013 static char *tmp
= NULL
;
1014 static unsigned int tmplen
= 0;
1016 gdb_assert (symbol_names
!= NULL
);
1018 for (objfile
*objfile
: current_program_space
->objfiles ())
1020 unsigned int *objc_csym
;
1022 /* The objfile_csym variable counts the number of ObjC methods
1023 that this objfile defines. We save that count as a private
1024 objfile data. If we have already determined that this objfile
1025 provides no ObjC methods, we can skip it entirely. */
1027 unsigned int objfile_csym
= 0;
1029 objc_csym
= objc_objfile_data
.get (objfile
);
1030 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1031 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1034 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1038 /* Check the symbol name first as this can be done entirely without
1039 sending any query to the target. */
1040 symname
= msymbol
->natural_name ();
1041 if (symname
== NULL
)
1044 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1045 /* Not a method name. */
1050 /* Now that thinks are a bit sane, clean up the symname. */
1051 while ((strlen (symname
) + 1) >= tmplen
)
1053 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1054 tmp
= (char *) xrealloc (tmp
, tmplen
);
1056 strcpy (tmp
, symname
);
1058 if (parse_method (tmp
, &ntype
, &nclass
,
1059 &ncategory
, &nselector
) == NULL
)
1062 if ((type
!= '\0') && (ntype
!= type
))
1065 if ((theclass
!= NULL
)
1066 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1069 if ((category
!= NULL
) &&
1070 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1073 if ((selector
!= NULL
) &&
1074 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1077 symbol_names
->push_back (symname
);
1080 if (objc_csym
== NULL
)
1081 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1083 /* Count of ObjC methods in this objfile should be constant. */
1084 gdb_assert (*objc_csym
== objfile_csym
);
1088 /* Uniquify a vector of strings. */
1091 uniquify_strings (std::vector
<const char *> *strings
)
1093 if (strings
->empty ())
1096 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1097 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1102 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1104 * Input: a string representing a selector
1105 * a pointer to an array of symbol pointers
1106 * possibly a pointer to a symbol found by the caller.
1108 * Output: number of methods that implement that selector. Side
1109 * effects: The array of symbol pointers is filled with matching syms.
1111 * By analogy with function "find_methods" (symtab.c), builds a list
1112 * of symbols matching the ambiguous input, so that "decode_line_2"
1113 * (symtab.c) can list them and ask the user to choose one or more.
1114 * In this case the matches are objective c methods
1115 * ("implementations") matching an objective c selector.
1117 * Note that it is possible for a normal (c-style) function to have
1118 * the same name as an objective c selector. To prevent the selector
1119 * from eclipsing the function, we allow the caller (decode_line_1) to
1120 * search for such a function first, and if it finds one, pass it in
1121 * to us. We will then integrate it into the list. We also search
1122 * for one here, among the minsyms.
1124 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1125 * into two parts: debuggable (struct symbol) syms, and
1126 * non_debuggable (struct minimal_symbol) syms. The debuggable
1127 * ones will come first, before NUM_DEBUGGABLE (which will thus
1128 * be the index of the first non-debuggable one).
1132 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1135 char *theclass
= NULL
;
1136 char *category
= NULL
;
1137 char *selector
= NULL
;
1142 int selector_case
= 0;
1144 gdb_assert (symbol_names
!= NULL
);
1146 buf
= (char *) alloca (strlen (method
) + 1);
1147 strcpy (buf
, method
);
1148 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1152 strcpy (buf
, method
);
1153 tmp
= parse_selector (buf
, &selector
);
1161 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1163 /* If we hit the "selector" case, and we found some methods, then
1164 add the selector itself as a symbol, if it exists. */
1165 if (selector_case
&& !symbol_names
->empty ())
1167 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1171 symbol_names
->push_back (sym
->natural_name ());
1174 struct bound_minimal_symbol msym
1175 = lookup_minimal_symbol (selector
, 0, 0);
1177 if (msym
.minsym
!= NULL
)
1178 symbol_names
->push_back (msym
.minsym
->natural_name ());
1182 uniquify_strings (symbol_names
);
1184 return method
+ (tmp
- buf
);
1188 print_object_command (const char *args
, int from_tty
)
1190 struct value
*object
, *function
, *description
;
1191 CORE_ADDR string_addr
, object_addr
;
1195 if (!args
|| !*args
)
1197 "The 'print-object' command requires an argument (an Objective-C object)");
1200 expression_up expr
= parse_expression (args
);
1203 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1204 expr
.get (), &pc
, EVAL_NORMAL
);
1207 /* Validate the address for sanity. */
1208 object_addr
= value_as_long (object
);
1209 read_memory (object_addr
, &c
, 1);
1211 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1212 if (function
== NULL
)
1213 error (_("Unable to locate _NSPrintForDebugger in child process"));
1215 description
= call_function_by_hand (function
, NULL
, object
);
1217 string_addr
= value_as_long (description
);
1218 if (string_addr
== 0)
1219 error (_("object returns null description"));
1221 read_memory (string_addr
+ i
++, &c
, 1);
1224 { /* Read and print characters up to EOS. */
1226 printf_filtered ("%c", c
);
1227 read_memory (string_addr
+ i
++, &c
, 1);
1230 printf_filtered(_("<object returns empty description>"));
1231 printf_filtered ("\n");
1234 /* The data structure 'methcalls' is used to detect method calls (thru
1235 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1236 * and ultimately find the method being called.
1239 struct objc_methcall
{
1241 /* Return instance method to be called. */
1242 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1243 /* Start of pc range corresponding to method invocation. */
1245 /* End of pc range corresponding to method invocation. */
1249 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1250 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1251 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1252 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1254 static struct objc_methcall methcalls
[] = {
1255 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1256 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1257 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1258 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1259 { "_objc_getClass", NULL
, 0, 0},
1260 { "_objc_getMetaClass", NULL
, 0, 0}
1263 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1265 /* The following function, "find_objc_msgsend", fills in the data
1266 * structure "objc_msgs" by finding the addresses of each of the
1267 * (currently four) functions that it holds (of which objc_msgSend is
1268 * the first). This must be called each time symbols are loaded, in
1269 * case the functions have moved for some reason.
1273 find_objc_msgsend (void)
1277 for (i
= 0; i
< nmethcalls
; i
++)
1279 struct bound_minimal_symbol func
;
1281 /* Try both with and without underscore. */
1282 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1283 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1285 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1287 if (func
.minsym
== NULL
)
1289 methcalls
[i
].begin
= 0;
1290 methcalls
[i
].end
= 0;
1294 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1295 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1299 /* find_objc_msgcall (replaces pc_off_limits)
1301 * ALL that this function now does is to determine whether the input
1302 * address ("pc") is the address of one of the Objective-C message
1303 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1304 * if so, it returns the address of the method that will be called.
1306 * The old function "pc_off_limits" used to do a lot of other things
1307 * in addition, such as detecting shared library jump stubs and
1308 * returning the address of the shlib function that would be called.
1309 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1310 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1311 * dependent modules.
1315 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1321 if (f (pc
, new_pc
) == 0)
1324 catch (const gdb_exception
&ex
)
1326 exception_fprintf (gdb_stderr
, ex
,
1327 "Unable to determine target of "
1328 "Objective-C method call (ignoring):\n");
1335 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1339 find_objc_msgsend ();
1345 for (i
= 0; i
< nmethcalls
; i
++)
1346 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1348 if (methcalls
[i
].stop_at
!= NULL
)
1349 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1358 void _initialize_objc_language ();
1360 _initialize_objc_language ()
1362 add_info ("selectors", info_selectors_command
,
1363 _("All Objective-C selectors, or those matching REGEXP."));
1364 add_info ("classes", info_classes_command
,
1365 _("All Objective-C classes, or those matching REGEXP."));
1366 add_com ("print-object", class_vars
, print_object_command
,
1367 _("Ask an Objective-C object to print itself."));
1368 add_com_alias ("po", "print-object", class_vars
, 1);
1372 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1373 struct objc_method
*method
)
1375 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1377 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1378 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1379 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1382 static unsigned long
1383 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1385 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1387 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1391 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1392 unsigned long num
, struct objc_method
*method
)
1394 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1395 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1399 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1400 struct objc_object
*object
)
1402 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1404 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1408 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1409 struct objc_super
*super
)
1411 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1413 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1414 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1418 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1419 struct objc_class
*theclass
)
1421 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1423 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1424 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1425 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1426 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1427 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1428 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1430 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1431 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1432 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1433 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1437 find_implementation_from_class (struct gdbarch
*gdbarch
,
1438 CORE_ADDR theclass
, CORE_ADDR sel
)
1440 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1441 CORE_ADDR subclass
= theclass
;
1443 while (subclass
!= 0)
1446 struct objc_class class_str
;
1447 unsigned mlistnum
= 0;
1449 read_objc_class (gdbarch
, subclass
, &class_str
);
1454 unsigned long nmethods
;
1457 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1463 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1465 for (i
= 0; i
< nmethods
; i
++)
1467 struct objc_method meth_str
;
1469 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1471 if (meth_str
.name
== sel
)
1472 /* FIXME: hppa arch was doing a pointer dereference
1473 here. There needs to be a better way to do that. */
1474 return meth_str
.imp
;
1478 subclass
= class_str
.super_class
;
1485 find_implementation (struct gdbarch
*gdbarch
,
1486 CORE_ADDR object
, CORE_ADDR sel
)
1488 struct objc_object ostr
;
1492 read_objc_object (gdbarch
, object
, &ostr
);
1496 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1500 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1502 struct frame_info
*frame
= get_current_frame ();
1503 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1504 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1510 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1511 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1513 res
= find_implementation (gdbarch
, object
, sel
);
1522 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1524 struct frame_info
*frame
= get_current_frame ();
1525 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1526 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1532 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1533 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1535 res
= find_implementation (gdbarch
, object
, sel
);
1544 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1546 struct frame_info
*frame
= get_current_frame ();
1547 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1548 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1550 struct objc_super sstr
;
1556 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1557 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1559 read_objc_super (gdbarch
, super
, &sstr
);
1560 if (sstr
.theclass
== 0)
1563 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1572 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1574 struct frame_info
*frame
= get_current_frame ();
1575 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1576 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1578 struct objc_super sstr
;
1584 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1585 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1587 read_objc_super (gdbarch
, super
, &sstr
);
1588 if (sstr
.theclass
== 0)
1591 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);