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 NULL
, /* Language specific
352 class_name_from_physname */
353 objc_op_print_tab
, /* Expression operators for printing */
354 1, /* C-style arrays */
355 0, /* String lower bound */
356 default_word_break_characters
,
357 default_collect_symbol_completion_matches
,
358 c_watch_location_expression
,
359 NULL
, /* la_get_symbol_name_matcher */
363 "{...}" /* la_struct_too_deep_ellipsis */
366 /* Class representing the Objective-C language. */
368 class objc_language
: public language_defn
372 : language_defn (language_objc
, objc_language_data
)
375 /* See language.h. */
376 void language_arch_info (struct gdbarch
*gdbarch
,
377 struct language_arch_info
*lai
) const override
379 c_language_arch_info (gdbarch
, lai
);
382 /* See language.h. */
383 bool sniff_from_mangled_name (const char *mangled
,
384 char **demangled
) const override
386 *demangled
= objc_demangle (mangled
, 0);
387 return *demangled
!= NULL
;
390 /* See language.h. */
392 char *demangle (const char *mangled
, int options
) const override
394 return objc_demangle (mangled
, options
);
397 /* See language.h. */
399 void print_type (struct type
*type
, const char *varstring
,
400 struct ui_file
*stream
, int show
, int level
,
401 const struct type_print_options
*flags
) const override
403 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
406 /* See language.h. */
408 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
409 CORE_ADDR stop_pc
) const override
411 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
412 CORE_ADDR real_stop_pc
;
413 CORE_ADDR method_stop_pc
;
415 /* Determine if we are currently in the Objective-C dispatch function.
416 If so, get the address of the method function that the dispatcher
417 would call and use that as the function to step into instead. Also
418 skip over the trampoline for the function (if any). This is better
419 for the user since they are only interested in stepping into the
420 method function anyway. */
422 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
424 if (real_stop_pc
!= 0)
425 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
427 find_objc_msgcall (stop_pc
, &method_stop_pc
);
431 real_stop_pc
= gdbarch_skip_trampoline_code
432 (gdbarch
, frame
, method_stop_pc
);
433 if (real_stop_pc
== 0)
434 real_stop_pc
= method_stop_pc
;
441 /* Single instance of the class representing the Objective-C language. */
443 static objc_language objc_language_defn
;
447 * Following functions help construct Objective-C message calls.
450 struct selname
/* For parsing Objective-C. */
452 struct selname
*next
;
457 static int msglist_len
;
458 static struct selname
*selname_chain
;
459 static char *msglist_sel
;
464 struct selname
*newobj
= XNEW (struct selname
);
466 newobj
->next
= selname_chain
;
467 newobj
->msglist_len
= msglist_len
;
468 newobj
->msglist_sel
= msglist_sel
;
470 msglist_sel
= (char *)xmalloc(1);
472 selname_chain
= newobj
;
476 add_msglist(struct stoken
*str
, int addcolon
)
482 if (str
== 0) /* Unnamed arg, or... */
484 if (addcolon
== 0) /* variable number of args. */
497 len
= plen
+ strlen(msglist_sel
) + 2;
498 s
= (char *)xmalloc(len
);
499 strcpy(s
, msglist_sel
);
514 end_msglist (struct parser_state
*ps
)
516 int val
= msglist_len
;
517 struct selname
*sel
= selname_chain
;
518 char *p
= msglist_sel
;
521 selname_chain
= sel
->next
;
522 msglist_len
= sel
->msglist_len
;
523 msglist_sel
= sel
->msglist_sel
;
524 selid
= lookup_child_selector (ps
->gdbarch (), p
);
526 error (_("Can't find selector \"%s\""), p
);
527 write_exp_elt_longcst (ps
, selid
);
529 write_exp_elt_longcst (ps
, val
); /* Number of args */
536 * Function: specialcmp (const char *a, const char *b)
538 * Special strcmp: treats ']' and ' ' as end-of-string.
539 * Used for qsorting lists of objc methods (either by class or selector).
543 specialcmp (const char *a
, const char *b
)
545 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
551 if (*a
&& *a
!= ' ' && *a
!= ']')
552 return 1; /* a is longer therefore greater. */
553 if (*b
&& *b
!= ' ' && *b
!= ']')
554 return -1; /* a is shorter therefore lesser. */
555 return 0; /* a and b are identical. */
559 * Function: compare_selectors (const void *, const void *)
561 * Comparison function for use with qsort. Arguments are symbols or
562 * msymbols Compares selector part of objc method name alphabetically.
566 compare_selectors (const void *a
, const void *b
)
568 const char *aname
, *bname
;
570 aname
= (*(struct symbol
**) a
)->print_name ();
571 bname
= (*(struct symbol
**) b
)->print_name ();
572 if (aname
== NULL
|| bname
== NULL
)
573 error (_("internal: compare_selectors(1)"));
575 aname
= strchr(aname
, ' ');
576 bname
= strchr(bname
, ' ');
577 if (aname
== NULL
|| bname
== NULL
)
578 error (_("internal: compare_selectors(2)"));
580 return specialcmp (aname
+1, bname
+1);
584 * Function: selectors_info (regexp, from_tty)
586 * Implements the "Info selectors" command. Takes an optional regexp
587 * arg. Lists all objective c selectors that match the regexp. Works
588 * by grepping thru all symbols for objective c methods. Output list
589 * is sorted and uniqued.
593 info_selectors_command (const char *regexp
, int from_tty
)
602 struct symbol
**sym_arr
;
606 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
609 if (*regexp
== '+' || *regexp
== '-')
610 { /* User wants only class methods or only instance methods. */
611 plusminus
= *regexp
++;
612 while (*regexp
== ' ' || *regexp
== '\t')
616 strcpy(myregexp
, ".*]");
619 /* Allow a few extra bytes because of the strcat below. */
620 if (sizeof (myregexp
) < strlen (regexp
) + 4)
621 error (_("Regexp is too long: %s"), regexp
);
622 strcpy(myregexp
, regexp
);
623 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
624 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
626 strcat(myregexp
, ".*]");
632 val
= re_comp (myregexp
);
634 error (_("Invalid regexp (%s): %s"), val
, regexp
);
637 /* First time thru is JUST to get max length and count. */
638 for (objfile
*objfile
: current_program_space
->objfiles ())
640 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
643 name
= msymbol
->natural_name ();
645 && (name
[0] == '-' || name
[0] == '+')
646 && name
[1] == '[') /* Got a method name. */
648 /* Filter for class/instance methods. */
649 if (plusminus
&& name
[0] != plusminus
)
651 /* Find selector part. */
652 name
= (char *) strchr (name
+2, ' ');
655 complaint (_("Bad method name '%s'"),
656 msymbol
->natural_name ());
659 if (regexp
== NULL
|| re_exec(++name
) != 0)
661 const char *mystart
= name
;
662 const char *myend
= strchr (mystart
, ']');
664 if (myend
&& (myend
- mystart
> maxlen
))
665 maxlen
= myend
- mystart
; /* Get longest selector. */
673 printf_filtered (_("Selectors matching \"%s\":\n\n"),
674 regexp
? regexp
: "*");
676 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
678 for (objfile
*objfile
: current_program_space
->objfiles ())
680 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
683 name
= msymbol
->natural_name ();
685 (name
[0] == '-' || name
[0] == '+') &&
686 name
[1] == '[') /* Got a method name. */
688 /* Filter for class/instance methods. */
689 if (plusminus
&& name
[0] != plusminus
)
691 /* Find selector part. */
692 name
= (char *) strchr(name
+2, ' ');
693 if (regexp
== NULL
|| re_exec(++name
) != 0)
694 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
699 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
701 /* Prevent compare on first iteration. */
703 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
708 name
= sym_arr
[ix
]->natural_name ();
709 name
= strchr (name
, ' ') + 1;
710 if (p
[0] && specialcmp(name
, p
) == 0)
711 continue; /* Seen this one already (not unique). */
713 /* Copy selector part. */
714 while (*name
&& *name
!= ']')
717 /* Print in columns. */
718 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
723 printf_filtered (_("No selectors matching \"%s\"\n"),
724 regexp
? regexp
: "*");
728 * Function: compare_classes (const void *, const void *)
730 * Comparison function for use with qsort. Arguments are symbols or
731 * msymbols Compares class part of objc method name alphabetically.
735 compare_classes (const void *a
, const void *b
)
737 const char *aname
, *bname
;
739 aname
= (*(struct symbol
**) a
)->print_name ();
740 bname
= (*(struct symbol
**) b
)->print_name ();
741 if (aname
== NULL
|| bname
== NULL
)
742 error (_("internal: compare_classes(1)"));
744 return specialcmp (aname
+1, bname
+1);
748 * Function: classes_info(regexp, from_tty)
750 * Implements the "info classes" command for objective c classes.
751 * Lists all objective c classes that match the optional regexp.
752 * Works by grepping thru the list of objective c methods. List will
753 * be sorted and uniqued (since one class may have many methods).
754 * BUGS: will not list a class that has no methods.
758 info_classes_command (const char *regexp
, int from_tty
)
767 struct symbol
**sym_arr
;
770 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
773 /* Allow a few extra bytes because of the strcat below. */
774 if (sizeof (myregexp
) < strlen (regexp
) + 4)
775 error (_("Regexp is too long: %s"), regexp
);
776 strcpy(myregexp
, regexp
);
777 if (myregexp
[strlen(myregexp
) - 1] == '$')
778 /* In the method name, the end of the class name is marked by ' '. */
779 myregexp
[strlen(myregexp
) - 1] = ' ';
781 strcat(myregexp
, ".* ");
786 val
= re_comp (myregexp
);
788 error (_("Invalid regexp (%s): %s"), val
, regexp
);
791 /* First time thru is JUST to get max length and count. */
792 for (objfile
*objfile
: current_program_space
->objfiles ())
794 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
797 name
= msymbol
->natural_name ();
799 (name
[0] == '-' || name
[0] == '+') &&
800 name
[1] == '[') /* Got a method name. */
801 if (regexp
== NULL
|| re_exec(name
+2) != 0)
803 /* Compute length of classname part. */
804 const char *mystart
= name
+ 2;
805 const char *myend
= strchr (mystart
, ' ');
807 if (myend
&& (myend
- mystart
> maxlen
))
808 maxlen
= myend
- mystart
;
815 printf_filtered (_("Classes matching \"%s\":\n\n"),
816 regexp
? regexp
: "*");
817 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
819 for (objfile
*objfile
: current_program_space
->objfiles ())
821 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
824 name
= msymbol
->natural_name ();
826 (name
[0] == '-' || name
[0] == '+') &&
827 name
[1] == '[') /* Got a method name. */
828 if (regexp
== NULL
|| re_exec(name
+2) != 0)
829 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
833 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
835 /* Prevent compare on first iteration. */
837 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
842 name
= sym_arr
[ix
]->natural_name ();
844 if (p
[0] && specialcmp(name
, p
) == 0)
845 continue; /* Seen this one already (not unique). */
847 /* Copy class part of method name. */
848 while (*name
&& *name
!= ' ')
851 /* Print in columns. */
852 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
857 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
861 parse_selector (char *method
, char **selector
)
867 char *nselector
= NULL
;
869 gdb_assert (selector
!= NULL
);
873 s1
= skip_spaces (s1
);
879 s1
= skip_spaces (s1
);
886 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
888 else if (isspace (*s2
))
890 else if ((*s2
== '\0') || (*s2
== '\''))
898 s2
= skip_spaces (s2
);
903 s2
= skip_spaces (s2
);
906 if (selector
!= NULL
)
907 *selector
= nselector
;
913 parse_method (char *method
, char *type
, char **theclass
,
914 char **category
, char **selector
)
922 char *ncategory
= NULL
;
923 char *nselector
= NULL
;
925 gdb_assert (type
!= NULL
);
926 gdb_assert (theclass
!= NULL
);
927 gdb_assert (category
!= NULL
);
928 gdb_assert (selector
!= NULL
);
932 s1
= skip_spaces (s1
);
938 s1
= skip_spaces (s1
);
940 if ((s1
[0] == '+') || (s1
[0] == '-'))
943 s1
= skip_spaces (s1
);
950 while (isalnum (*s1
) || (*s1
== '_'))
954 s2
= skip_spaces (s2
);
959 s2
= skip_spaces (s2
);
961 while (isalnum (*s2
) || (*s2
== '_'))
966 /* Truncate the class name now that we're not using the open paren. */
974 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
976 else if (isspace (*s2
))
987 s2
= skip_spaces (s2
);
993 s2
= skip_spaces (s2
);
998 if (theclass
!= NULL
)
1000 if (category
!= NULL
)
1001 *category
= ncategory
;
1002 if (selector
!= NULL
)
1003 *selector
= nselector
;
1009 find_methods (char type
, const char *theclass
, const char *category
,
1010 const char *selector
,
1011 std::vector
<const char *> *symbol_names
)
1013 const char *symname
= NULL
;
1016 char *nclass
= NULL
;
1017 char *ncategory
= NULL
;
1018 char *nselector
= NULL
;
1020 static char *tmp
= NULL
;
1021 static unsigned int tmplen
= 0;
1023 gdb_assert (symbol_names
!= NULL
);
1025 for (objfile
*objfile
: current_program_space
->objfiles ())
1027 unsigned int *objc_csym
;
1029 /* The objfile_csym variable counts the number of ObjC methods
1030 that this objfile defines. We save that count as a private
1031 objfile data. If we have already determined that this objfile
1032 provides no ObjC methods, we can skip it entirely. */
1034 unsigned int objfile_csym
= 0;
1036 objc_csym
= objc_objfile_data
.get (objfile
);
1037 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1038 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1041 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1045 /* Check the symbol name first as this can be done entirely without
1046 sending any query to the target. */
1047 symname
= msymbol
->natural_name ();
1048 if (symname
== NULL
)
1051 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1052 /* Not a method name. */
1057 /* Now that thinks are a bit sane, clean up the symname. */
1058 while ((strlen (symname
) + 1) >= tmplen
)
1060 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1061 tmp
= (char *) xrealloc (tmp
, tmplen
);
1063 strcpy (tmp
, symname
);
1065 if (parse_method (tmp
, &ntype
, &nclass
,
1066 &ncategory
, &nselector
) == NULL
)
1069 if ((type
!= '\0') && (ntype
!= type
))
1072 if ((theclass
!= NULL
)
1073 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1076 if ((category
!= NULL
) &&
1077 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1080 if ((selector
!= NULL
) &&
1081 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1084 symbol_names
->push_back (symname
);
1087 if (objc_csym
== NULL
)
1088 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1090 /* Count of ObjC methods in this objfile should be constant. */
1091 gdb_assert (*objc_csym
== objfile_csym
);
1095 /* Uniquify a vector of strings. */
1098 uniquify_strings (std::vector
<const char *> *strings
)
1100 if (strings
->empty ())
1103 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1104 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1109 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1111 * Input: a string representing a selector
1112 * a pointer to an array of symbol pointers
1113 * possibly a pointer to a symbol found by the caller.
1115 * Output: number of methods that implement that selector. Side
1116 * effects: The array of symbol pointers is filled with matching syms.
1118 * By analogy with function "find_methods" (symtab.c), builds a list
1119 * of symbols matching the ambiguous input, so that "decode_line_2"
1120 * (symtab.c) can list them and ask the user to choose one or more.
1121 * In this case the matches are objective c methods
1122 * ("implementations") matching an objective c selector.
1124 * Note that it is possible for a normal (c-style) function to have
1125 * the same name as an objective c selector. To prevent the selector
1126 * from eclipsing the function, we allow the caller (decode_line_1) to
1127 * search for such a function first, and if it finds one, pass it in
1128 * to us. We will then integrate it into the list. We also search
1129 * for one here, among the minsyms.
1131 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1132 * into two parts: debuggable (struct symbol) syms, and
1133 * non_debuggable (struct minimal_symbol) syms. The debuggable
1134 * ones will come first, before NUM_DEBUGGABLE (which will thus
1135 * be the index of the first non-debuggable one).
1139 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1142 char *theclass
= NULL
;
1143 char *category
= NULL
;
1144 char *selector
= NULL
;
1149 int selector_case
= 0;
1151 gdb_assert (symbol_names
!= NULL
);
1153 buf
= (char *) alloca (strlen (method
) + 1);
1154 strcpy (buf
, method
);
1155 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1159 strcpy (buf
, method
);
1160 tmp
= parse_selector (buf
, &selector
);
1168 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1170 /* If we hit the "selector" case, and we found some methods, then
1171 add the selector itself as a symbol, if it exists. */
1172 if (selector_case
&& !symbol_names
->empty ())
1174 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1178 symbol_names
->push_back (sym
->natural_name ());
1181 struct bound_minimal_symbol msym
1182 = lookup_minimal_symbol (selector
, 0, 0);
1184 if (msym
.minsym
!= NULL
)
1185 symbol_names
->push_back (msym
.minsym
->natural_name ());
1189 uniquify_strings (symbol_names
);
1191 return method
+ (tmp
- buf
);
1195 print_object_command (const char *args
, int from_tty
)
1197 struct value
*object
, *function
, *description
;
1198 CORE_ADDR string_addr
, object_addr
;
1202 if (!args
|| !*args
)
1204 "The 'print-object' command requires an argument (an Objective-C object)");
1207 expression_up expr
= parse_expression (args
);
1210 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1211 expr
.get (), &pc
, EVAL_NORMAL
);
1214 /* Validate the address for sanity. */
1215 object_addr
= value_as_long (object
);
1216 read_memory (object_addr
, &c
, 1);
1218 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1219 if (function
== NULL
)
1220 error (_("Unable to locate _NSPrintForDebugger in child process"));
1222 description
= call_function_by_hand (function
, NULL
, object
);
1224 string_addr
= value_as_long (description
);
1225 if (string_addr
== 0)
1226 error (_("object returns null description"));
1228 read_memory (string_addr
+ i
++, &c
, 1);
1231 { /* Read and print characters up to EOS. */
1233 printf_filtered ("%c", c
);
1234 read_memory (string_addr
+ i
++, &c
, 1);
1237 printf_filtered(_("<object returns empty description>"));
1238 printf_filtered ("\n");
1241 /* The data structure 'methcalls' is used to detect method calls (thru
1242 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1243 * and ultimately find the method being called.
1246 struct objc_methcall
{
1248 /* Return instance method to be called. */
1249 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1250 /* Start of pc range corresponding to method invocation. */
1252 /* End of pc range corresponding to method invocation. */
1256 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1257 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1258 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1259 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1261 static struct objc_methcall methcalls
[] = {
1262 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1263 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1264 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1265 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1266 { "_objc_getClass", NULL
, 0, 0},
1267 { "_objc_getMetaClass", NULL
, 0, 0}
1270 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1272 /* The following function, "find_objc_msgsend", fills in the data
1273 * structure "objc_msgs" by finding the addresses of each of the
1274 * (currently four) functions that it holds (of which objc_msgSend is
1275 * the first). This must be called each time symbols are loaded, in
1276 * case the functions have moved for some reason.
1280 find_objc_msgsend (void)
1284 for (i
= 0; i
< nmethcalls
; i
++)
1286 struct bound_minimal_symbol func
;
1288 /* Try both with and without underscore. */
1289 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1290 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1292 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1294 if (func
.minsym
== NULL
)
1296 methcalls
[i
].begin
= 0;
1297 methcalls
[i
].end
= 0;
1301 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1302 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1306 /* find_objc_msgcall (replaces pc_off_limits)
1308 * ALL that this function now does is to determine whether the input
1309 * address ("pc") is the address of one of the Objective-C message
1310 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1311 * if so, it returns the address of the method that will be called.
1313 * The old function "pc_off_limits" used to do a lot of other things
1314 * in addition, such as detecting shared library jump stubs and
1315 * returning the address of the shlib function that would be called.
1316 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1317 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1318 * dependent modules.
1322 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1328 if (f (pc
, new_pc
) == 0)
1331 catch (const gdb_exception
&ex
)
1333 exception_fprintf (gdb_stderr
, ex
,
1334 "Unable to determine target of "
1335 "Objective-C method call (ignoring):\n");
1342 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1346 find_objc_msgsend ();
1352 for (i
= 0; i
< nmethcalls
; i
++)
1353 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1355 if (methcalls
[i
].stop_at
!= NULL
)
1356 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1365 void _initialize_objc_language ();
1367 _initialize_objc_language ()
1369 add_info ("selectors", info_selectors_command
,
1370 _("All Objective-C selectors, or those matching REGEXP."));
1371 add_info ("classes", info_classes_command
,
1372 _("All Objective-C classes, or those matching REGEXP."));
1373 add_com ("print-object", class_vars
, print_object_command
,
1374 _("Ask an Objective-C object to print itself."));
1375 add_com_alias ("po", "print-object", class_vars
, 1);
1379 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1380 struct objc_method
*method
)
1382 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1384 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1385 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1386 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1389 static unsigned long
1390 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1392 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1394 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1398 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1399 unsigned long num
, struct objc_method
*method
)
1401 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1402 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1406 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1407 struct objc_object
*object
)
1409 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1411 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1415 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1416 struct objc_super
*super
)
1418 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1420 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1421 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1425 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1426 struct objc_class
*theclass
)
1428 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1430 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1431 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1432 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1433 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1434 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1435 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1437 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1438 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1439 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1440 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1444 find_implementation_from_class (struct gdbarch
*gdbarch
,
1445 CORE_ADDR theclass
, CORE_ADDR sel
)
1447 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1448 CORE_ADDR subclass
= theclass
;
1450 while (subclass
!= 0)
1453 struct objc_class class_str
;
1454 unsigned mlistnum
= 0;
1456 read_objc_class (gdbarch
, subclass
, &class_str
);
1461 unsigned long nmethods
;
1464 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1470 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1472 for (i
= 0; i
< nmethods
; i
++)
1474 struct objc_method meth_str
;
1476 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1478 if (meth_str
.name
== sel
)
1479 /* FIXME: hppa arch was doing a pointer dereference
1480 here. There needs to be a better way to do that. */
1481 return meth_str
.imp
;
1485 subclass
= class_str
.super_class
;
1492 find_implementation (struct gdbarch
*gdbarch
,
1493 CORE_ADDR object
, CORE_ADDR sel
)
1495 struct objc_object ostr
;
1499 read_objc_object (gdbarch
, object
, &ostr
);
1503 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1507 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1509 struct frame_info
*frame
= get_current_frame ();
1510 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1511 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1517 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1518 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1520 res
= find_implementation (gdbarch
, object
, sel
);
1529 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1531 struct frame_info
*frame
= get_current_frame ();
1532 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1533 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1539 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1540 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1542 res
= find_implementation (gdbarch
, object
, sel
);
1551 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1553 struct frame_info
*frame
= get_current_frame ();
1554 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1555 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1557 struct objc_super sstr
;
1563 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1564 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1566 read_objc_super (gdbarch
, super
, &sstr
);
1567 if (sstr
.theclass
== 0)
1570 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1579 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1581 struct frame_info
*frame
= get_current_frame ();
1582 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1583 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1585 struct objc_super sstr
;
1591 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1592 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1594 read_objc_super (gdbarch
, super
, &sstr
);
1595 if (sstr
.theclass
== 0)
1598 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);