1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2020 Free Software Foundation, Inc.
5 Contributed by Apple Computer, Inc.
6 Written by Michael Snyder.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
27 #include "parser-defs.h"
31 #include "objc-lang.h"
32 #include "complaints.h"
36 #include "target.h" /* for target_has_execution */
40 #include "gdb_regex.h"
45 #include "cli/cli-utils.h"
56 CORE_ADDR super_class
;
78 static const struct objfile_key
<unsigned int> objc_objfile_data
;
80 /* Lookup a structure type named "struct NAME", visible in lexical
81 block BLOCK. If NOERR is nonzero, return zero if NAME is not
85 lookup_struct_typedef (const char *name
, const struct block
*block
, int noerr
)
89 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
96 error (_("No struct type named %s."), name
);
98 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
103 error (_("This context has class, union or enum %s, not a struct."),
110 lookup_objc_class (struct gdbarch
*gdbarch
, const char *classname
)
112 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
113 struct value
* function
, *classval
;
115 if (! target_has_execution
)
117 /* Can't call into inferior to lookup class. */
121 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0).minsym
)
122 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
123 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym
)
124 function
= find_function_in_inferior("objc_lookup_class", NULL
);
127 complaint (_("no way to lookup Objective-C classes"));
131 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
132 classval
= value_coerce_array (classval
);
133 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
139 lookup_child_selector (struct gdbarch
*gdbarch
, const char *selname
)
141 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
142 struct value
* function
, *selstring
;
144 if (! target_has_execution
)
146 /* Can't call into inferior to lookup selector. */
150 if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym
)
151 function
= find_function_in_inferior("sel_getUid", NULL
);
152 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym
)
153 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
156 complaint (_("no way to lookup Objective-C selectors"));
160 selstring
= value_coerce_array (value_string (selname
,
161 strlen (selname
) + 1,
163 return value_as_long (call_function_by_hand (function
, NULL
, selstring
));
167 value_nsstring (struct gdbarch
*gdbarch
, char *ptr
, int len
)
169 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
170 struct value
*stringValue
[3];
171 struct value
*function
, *nsstringValue
;
175 if (!target_has_execution
)
176 return 0; /* Can't call into inferior to create NSString. */
178 stringValue
[2] = value_string(ptr
, len
, char_type
);
179 stringValue
[2] = value_coerce_array(stringValue
[2]);
180 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
181 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym
)
183 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
184 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
186 else if (lookup_minimal_symbol("istr", 0, 0).minsym
)
188 function
= find_function_in_inferior("istr", NULL
);
189 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
191 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym
)
194 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
195 type
= builtin_type (gdbarch
)->builtin_long
;
197 stringValue
[0] = value_from_longest
198 (type
, lookup_objc_class (gdbarch
, "NSString"));
199 stringValue
[1] = value_from_longest
200 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
201 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
);
204 error (_("NSString: internal error -- no way to create new NSString"));
206 sym
= lookup_struct_typedef("NSString", 0, 1);
208 sym
= lookup_struct_typedef("NXString", 0, 1);
210 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
212 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
214 deprecated_set_value_type (nsstringValue
, type
);
215 return nsstringValue
;
218 /* Objective-C name demangling. */
221 objc_demangle (const char *mangled
, int options
)
223 char *demangled
, *cp
;
225 if (mangled
[0] == '_' &&
226 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
229 cp
= demangled
= (char *) xmalloc (strlen (mangled
) + 2);
231 if (mangled
[1] == 'i')
232 *cp
++ = '-'; /* for instance method */
234 *cp
++ = '+'; /* for class method */
236 *cp
++ = '['; /* opening left brace */
237 strcpy(cp
, mangled
+3); /* Tack on the rest of the mangled name. */
239 while (*cp
&& *cp
== '_')
240 cp
++; /* Skip any initial underbars in class
243 cp
= strchr(cp
, '_');
244 if (!cp
) /* Find first non-initial underbar. */
246 xfree(demangled
); /* not mangled name */
249 if (cp
[1] == '_') /* Easy case: no category name. */
251 *cp
++ = ' '; /* Replace two '_' with one ' '. */
252 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
256 *cp
++ = '('; /* Less easy case: category name. */
257 cp
= strchr(cp
, '_');
260 xfree(demangled
); /* not mangled name */
264 *cp
++ = ' '; /* Overwriting 1st char of method name... */
265 strcpy(cp
, mangled
+ (cp
- demangled
)); /* Get it back. */
268 while (*cp
&& *cp
== '_')
269 cp
++; /* Skip any initial underbars in
274 *cp
= ':'; /* Replace remaining '_' with ':'. */
276 *cp
++ = ']'; /* closing right brace */
277 *cp
++ = 0; /* string terminator */
281 return NULL
; /* Not an objc mangled name. */
285 /* Table mapping opcodes into strings for printing operators
286 and precedences of the operators. */
288 static const struct op_print objc_op_print_tab
[] =
290 {",", BINOP_COMMA
, PREC_COMMA
, 0},
291 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
292 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
293 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
294 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
295 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
296 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
297 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
298 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
299 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
300 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
301 {">", BINOP_GTR
, PREC_ORDER
, 0},
302 {"<", BINOP_LESS
, PREC_ORDER
, 0},
303 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
304 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
305 {"+", BINOP_ADD
, PREC_ADD
, 0},
306 {"-", BINOP_SUB
, PREC_ADD
, 0},
307 {"*", BINOP_MUL
, PREC_MUL
, 0},
308 {"/", BINOP_DIV
, PREC_MUL
, 0},
309 {"%", BINOP_REM
, PREC_MUL
, 0},
310 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
311 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
312 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
313 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
314 {"*", UNOP_IND
, PREC_PREFIX
, 0},
315 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
316 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
317 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
318 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
319 {NULL
, OP_NULL
, PREC_NULL
, 0}
322 static const char *objc_extensions
[] =
327 /* Constant data representing the Objective-C language. */
329 extern const struct language_data objc_language_data
=
331 "objective-c", /* Language name */
339 &exp_descriptor_standard
,
342 c_printchar
, /* Print a character constant */
343 c_printstr
, /* Function to print string constant */
345 c_print_typedef
, /* Print a typedef using appropriate syntax */
346 c_value_print_inner
, /* la_value_print_inner */
347 c_value_print
, /* Print a top-level value */
348 "self", /* name_of_this */
349 false, /* la_store_sym_names_in_linkage_form_p */
350 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
351 objc_op_print_tab
, /* Expression operators for printing */
352 1, /* C-style arrays */
353 0, /* String lower bound */
354 default_word_break_characters
,
355 default_collect_symbol_completion_matches
,
356 c_watch_location_expression
,
357 NULL
, /* la_get_symbol_name_matcher */
360 "{...}" /* la_struct_too_deep_ellipsis */
363 /* Class representing the Objective-C language. */
365 class objc_language
: public language_defn
369 : language_defn (language_objc
, objc_language_data
)
372 /* See language.h. */
373 void language_arch_info (struct gdbarch
*gdbarch
,
374 struct language_arch_info
*lai
) const override
376 c_language_arch_info (gdbarch
, lai
);
379 /* See language.h. */
380 bool sniff_from_mangled_name (const char *mangled
,
381 char **demangled
) const override
383 *demangled
= objc_demangle (mangled
, 0);
384 return *demangled
!= NULL
;
387 /* See language.h. */
389 char *demangle (const char *mangled
, int options
) const override
391 return objc_demangle (mangled
, options
);
394 /* See language.h. */
396 void print_type (struct type
*type
, const char *varstring
,
397 struct ui_file
*stream
, int show
, int level
,
398 const struct type_print_options
*flags
) const override
400 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
403 /* See language.h. */
405 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
406 CORE_ADDR stop_pc
) const override
408 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
409 CORE_ADDR real_stop_pc
;
410 CORE_ADDR method_stop_pc
;
412 /* Determine if we are currently in the Objective-C dispatch function.
413 If so, get the address of the method function that the dispatcher
414 would call and use that as the function to step into instead. Also
415 skip over the trampoline for the function (if any). This is better
416 for the user since they are only interested in stepping into the
417 method function anyway. */
419 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
421 if (real_stop_pc
!= 0)
422 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
424 find_objc_msgcall (stop_pc
, &method_stop_pc
);
428 real_stop_pc
= gdbarch_skip_trampoline_code
429 (gdbarch
, frame
, method_stop_pc
);
430 if (real_stop_pc
== 0)
431 real_stop_pc
= method_stop_pc
;
438 /* Single instance of the class representing the Objective-C language. */
440 static objc_language objc_language_defn
;
444 * Following functions help construct Objective-C message calls.
447 struct selname
/* For parsing Objective-C. */
449 struct selname
*next
;
454 static int msglist_len
;
455 static struct selname
*selname_chain
;
456 static char *msglist_sel
;
461 struct selname
*newobj
= XNEW (struct selname
);
463 newobj
->next
= selname_chain
;
464 newobj
->msglist_len
= msglist_len
;
465 newobj
->msglist_sel
= msglist_sel
;
467 msglist_sel
= (char *)xmalloc(1);
469 selname_chain
= newobj
;
473 add_msglist(struct stoken
*str
, int addcolon
)
479 if (str
== 0) /* Unnamed arg, or... */
481 if (addcolon
== 0) /* variable number of args. */
494 len
= plen
+ strlen(msglist_sel
) + 2;
495 s
= (char *)xmalloc(len
);
496 strcpy(s
, msglist_sel
);
511 end_msglist (struct parser_state
*ps
)
513 int val
= msglist_len
;
514 struct selname
*sel
= selname_chain
;
515 char *p
= msglist_sel
;
518 selname_chain
= sel
->next
;
519 msglist_len
= sel
->msglist_len
;
520 msglist_sel
= sel
->msglist_sel
;
521 selid
= lookup_child_selector (ps
->gdbarch (), p
);
523 error (_("Can't find selector \"%s\""), p
);
524 write_exp_elt_longcst (ps
, selid
);
526 write_exp_elt_longcst (ps
, val
); /* Number of args */
533 * Function: specialcmp (const char *a, const char *b)
535 * Special strcmp: treats ']' and ' ' as end-of-string.
536 * Used for qsorting lists of objc methods (either by class or selector).
540 specialcmp (const char *a
, const char *b
)
542 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
548 if (*a
&& *a
!= ' ' && *a
!= ']')
549 return 1; /* a is longer therefore greater. */
550 if (*b
&& *b
!= ' ' && *b
!= ']')
551 return -1; /* a is shorter therefore lesser. */
552 return 0; /* a and b are identical. */
556 * Function: compare_selectors (const void *, const void *)
558 * Comparison function for use with qsort. Arguments are symbols or
559 * msymbols Compares selector part of objc method name alphabetically.
563 compare_selectors (const void *a
, const void *b
)
565 const char *aname
, *bname
;
567 aname
= (*(struct symbol
**) a
)->print_name ();
568 bname
= (*(struct symbol
**) b
)->print_name ();
569 if (aname
== NULL
|| bname
== NULL
)
570 error (_("internal: compare_selectors(1)"));
572 aname
= strchr(aname
, ' ');
573 bname
= strchr(bname
, ' ');
574 if (aname
== NULL
|| bname
== NULL
)
575 error (_("internal: compare_selectors(2)"));
577 return specialcmp (aname
+1, bname
+1);
581 * Function: selectors_info (regexp, from_tty)
583 * Implements the "Info selectors" command. Takes an optional regexp
584 * arg. Lists all objective c selectors that match the regexp. Works
585 * by grepping thru all symbols for objective c methods. Output list
586 * is sorted and uniqued.
590 info_selectors_command (const char *regexp
, int from_tty
)
599 struct symbol
**sym_arr
;
603 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
606 if (*regexp
== '+' || *regexp
== '-')
607 { /* User wants only class methods or only instance methods. */
608 plusminus
= *regexp
++;
609 while (*regexp
== ' ' || *regexp
== '\t')
613 strcpy(myregexp
, ".*]");
616 /* Allow a few extra bytes because of the strcat below. */
617 if (sizeof (myregexp
) < strlen (regexp
) + 4)
618 error (_("Regexp is too long: %s"), regexp
);
619 strcpy(myregexp
, regexp
);
620 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
621 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
623 strcat(myregexp
, ".*]");
629 val
= re_comp (myregexp
);
631 error (_("Invalid regexp (%s): %s"), val
, regexp
);
634 /* First time thru is JUST to get max length and count. */
635 for (objfile
*objfile
: current_program_space
->objfiles ())
637 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
640 name
= msymbol
->natural_name ();
642 && (name
[0] == '-' || name
[0] == '+')
643 && name
[1] == '[') /* Got a method name. */
645 /* Filter for class/instance methods. */
646 if (plusminus
&& name
[0] != plusminus
)
648 /* Find selector part. */
649 name
= (char *) strchr (name
+2, ' ');
652 complaint (_("Bad method name '%s'"),
653 msymbol
->natural_name ());
656 if (regexp
== NULL
|| re_exec(++name
) != 0)
658 const char *mystart
= name
;
659 const char *myend
= strchr (mystart
, ']');
661 if (myend
&& (myend
- mystart
> maxlen
))
662 maxlen
= myend
- mystart
; /* Get longest selector. */
670 printf_filtered (_("Selectors matching \"%s\":\n\n"),
671 regexp
? regexp
: "*");
673 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
675 for (objfile
*objfile
: current_program_space
->objfiles ())
677 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
680 name
= msymbol
->natural_name ();
682 (name
[0] == '-' || name
[0] == '+') &&
683 name
[1] == '[') /* Got a method name. */
685 /* Filter for class/instance methods. */
686 if (plusminus
&& name
[0] != plusminus
)
688 /* Find selector part. */
689 name
= (char *) strchr(name
+2, ' ');
690 if (regexp
== NULL
|| re_exec(++name
) != 0)
691 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
696 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
698 /* Prevent compare on first iteration. */
700 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
705 name
= sym_arr
[ix
]->natural_name ();
706 name
= strchr (name
, ' ') + 1;
707 if (p
[0] && specialcmp(name
, p
) == 0)
708 continue; /* Seen this one already (not unique). */
710 /* Copy selector part. */
711 while (*name
&& *name
!= ']')
714 /* Print in columns. */
715 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
720 printf_filtered (_("No selectors matching \"%s\"\n"),
721 regexp
? regexp
: "*");
725 * Function: compare_classes (const void *, const void *)
727 * Comparison function for use with qsort. Arguments are symbols or
728 * msymbols Compares class part of objc method name alphabetically.
732 compare_classes (const void *a
, const void *b
)
734 const char *aname
, *bname
;
736 aname
= (*(struct symbol
**) a
)->print_name ();
737 bname
= (*(struct symbol
**) b
)->print_name ();
738 if (aname
== NULL
|| bname
== NULL
)
739 error (_("internal: compare_classes(1)"));
741 return specialcmp (aname
+1, bname
+1);
745 * Function: classes_info(regexp, from_tty)
747 * Implements the "info classes" command for objective c classes.
748 * Lists all objective c classes that match the optional regexp.
749 * Works by grepping thru the list of objective c methods. List will
750 * be sorted and uniqued (since one class may have many methods).
751 * BUGS: will not list a class that has no methods.
755 info_classes_command (const char *regexp
, int from_tty
)
764 struct symbol
**sym_arr
;
767 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
770 /* Allow a few extra bytes because of the strcat below. */
771 if (sizeof (myregexp
) < strlen (regexp
) + 4)
772 error (_("Regexp is too long: %s"), regexp
);
773 strcpy(myregexp
, regexp
);
774 if (myregexp
[strlen(myregexp
) - 1] == '$')
775 /* In the method name, the end of the class name is marked by ' '. */
776 myregexp
[strlen(myregexp
) - 1] = ' ';
778 strcat(myregexp
, ".* ");
783 val
= re_comp (myregexp
);
785 error (_("Invalid regexp (%s): %s"), val
, regexp
);
788 /* First time thru is JUST to get max length and count. */
789 for (objfile
*objfile
: current_program_space
->objfiles ())
791 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
794 name
= msymbol
->natural_name ();
796 (name
[0] == '-' || name
[0] == '+') &&
797 name
[1] == '[') /* Got a method name. */
798 if (regexp
== NULL
|| re_exec(name
+2) != 0)
800 /* Compute length of classname part. */
801 const char *mystart
= name
+ 2;
802 const char *myend
= strchr (mystart
, ' ');
804 if (myend
&& (myend
- mystart
> maxlen
))
805 maxlen
= myend
- mystart
;
812 printf_filtered (_("Classes matching \"%s\":\n\n"),
813 regexp
? regexp
: "*");
814 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
816 for (objfile
*objfile
: current_program_space
->objfiles ())
818 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
821 name
= msymbol
->natural_name ();
823 (name
[0] == '-' || name
[0] == '+') &&
824 name
[1] == '[') /* Got a method name. */
825 if (regexp
== NULL
|| re_exec(name
+2) != 0)
826 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
830 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
832 /* Prevent compare on first iteration. */
834 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
839 name
= sym_arr
[ix
]->natural_name ();
841 if (p
[0] && specialcmp(name
, p
) == 0)
842 continue; /* Seen this one already (not unique). */
844 /* Copy class part of method name. */
845 while (*name
&& *name
!= ' ')
848 /* Print in columns. */
849 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
854 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
858 parse_selector (char *method
, char **selector
)
864 char *nselector
= NULL
;
866 gdb_assert (selector
!= NULL
);
870 s1
= skip_spaces (s1
);
876 s1
= skip_spaces (s1
);
883 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
885 else if (isspace (*s2
))
887 else if ((*s2
== '\0') || (*s2
== '\''))
895 s2
= skip_spaces (s2
);
900 s2
= skip_spaces (s2
);
903 if (selector
!= NULL
)
904 *selector
= nselector
;
910 parse_method (char *method
, char *type
, char **theclass
,
911 char **category
, char **selector
)
919 char *ncategory
= NULL
;
920 char *nselector
= NULL
;
922 gdb_assert (type
!= NULL
);
923 gdb_assert (theclass
!= NULL
);
924 gdb_assert (category
!= NULL
);
925 gdb_assert (selector
!= NULL
);
929 s1
= skip_spaces (s1
);
935 s1
= skip_spaces (s1
);
937 if ((s1
[0] == '+') || (s1
[0] == '-'))
940 s1
= skip_spaces (s1
);
947 while (isalnum (*s1
) || (*s1
== '_'))
951 s2
= skip_spaces (s2
);
956 s2
= skip_spaces (s2
);
958 while (isalnum (*s2
) || (*s2
== '_'))
963 /* Truncate the class name now that we're not using the open paren. */
971 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
973 else if (isspace (*s2
))
984 s2
= skip_spaces (s2
);
990 s2
= skip_spaces (s2
);
995 if (theclass
!= NULL
)
997 if (category
!= NULL
)
998 *category
= ncategory
;
999 if (selector
!= NULL
)
1000 *selector
= nselector
;
1006 find_methods (char type
, const char *theclass
, const char *category
,
1007 const char *selector
,
1008 std::vector
<const char *> *symbol_names
)
1010 const char *symname
= NULL
;
1013 char *nclass
= NULL
;
1014 char *ncategory
= NULL
;
1015 char *nselector
= NULL
;
1017 static char *tmp
= NULL
;
1018 static unsigned int tmplen
= 0;
1020 gdb_assert (symbol_names
!= NULL
);
1022 for (objfile
*objfile
: current_program_space
->objfiles ())
1024 unsigned int *objc_csym
;
1026 /* The objfile_csym variable counts the number of ObjC methods
1027 that this objfile defines. We save that count as a private
1028 objfile data. If we have already determined that this objfile
1029 provides no ObjC methods, we can skip it entirely. */
1031 unsigned int objfile_csym
= 0;
1033 objc_csym
= objc_objfile_data
.get (objfile
);
1034 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1035 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1038 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1042 /* Check the symbol name first as this can be done entirely without
1043 sending any query to the target. */
1044 symname
= msymbol
->natural_name ();
1045 if (symname
== NULL
)
1048 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1049 /* Not a method name. */
1054 /* Now that thinks are a bit sane, clean up the symname. */
1055 while ((strlen (symname
) + 1) >= tmplen
)
1057 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1058 tmp
= (char *) xrealloc (tmp
, tmplen
);
1060 strcpy (tmp
, symname
);
1062 if (parse_method (tmp
, &ntype
, &nclass
,
1063 &ncategory
, &nselector
) == NULL
)
1066 if ((type
!= '\0') && (ntype
!= type
))
1069 if ((theclass
!= NULL
)
1070 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1073 if ((category
!= NULL
) &&
1074 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1077 if ((selector
!= NULL
) &&
1078 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1081 symbol_names
->push_back (symname
);
1084 if (objc_csym
== NULL
)
1085 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1087 /* Count of ObjC methods in this objfile should be constant. */
1088 gdb_assert (*objc_csym
== objfile_csym
);
1092 /* Uniquify a vector of strings. */
1095 uniquify_strings (std::vector
<const char *> *strings
)
1097 if (strings
->empty ())
1100 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1101 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1106 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1108 * Input: a string representing a selector
1109 * a pointer to an array of symbol pointers
1110 * possibly a pointer to a symbol found by the caller.
1112 * Output: number of methods that implement that selector. Side
1113 * effects: The array of symbol pointers is filled with matching syms.
1115 * By analogy with function "find_methods" (symtab.c), builds a list
1116 * of symbols matching the ambiguous input, so that "decode_line_2"
1117 * (symtab.c) can list them and ask the user to choose one or more.
1118 * In this case the matches are objective c methods
1119 * ("implementations") matching an objective c selector.
1121 * Note that it is possible for a normal (c-style) function to have
1122 * the same name as an objective c selector. To prevent the selector
1123 * from eclipsing the function, we allow the caller (decode_line_1) to
1124 * search for such a function first, and if it finds one, pass it in
1125 * to us. We will then integrate it into the list. We also search
1126 * for one here, among the minsyms.
1128 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1129 * into two parts: debuggable (struct symbol) syms, and
1130 * non_debuggable (struct minimal_symbol) syms. The debuggable
1131 * ones will come first, before NUM_DEBUGGABLE (which will thus
1132 * be the index of the first non-debuggable one).
1136 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1139 char *theclass
= NULL
;
1140 char *category
= NULL
;
1141 char *selector
= NULL
;
1146 int selector_case
= 0;
1148 gdb_assert (symbol_names
!= NULL
);
1150 buf
= (char *) alloca (strlen (method
) + 1);
1151 strcpy (buf
, method
);
1152 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1156 strcpy (buf
, method
);
1157 tmp
= parse_selector (buf
, &selector
);
1165 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1167 /* If we hit the "selector" case, and we found some methods, then
1168 add the selector itself as a symbol, if it exists. */
1169 if (selector_case
&& !symbol_names
->empty ())
1171 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1175 symbol_names
->push_back (sym
->natural_name ());
1178 struct bound_minimal_symbol msym
1179 = lookup_minimal_symbol (selector
, 0, 0);
1181 if (msym
.minsym
!= NULL
)
1182 symbol_names
->push_back (msym
.minsym
->natural_name ());
1186 uniquify_strings (symbol_names
);
1188 return method
+ (tmp
- buf
);
1192 print_object_command (const char *args
, int from_tty
)
1194 struct value
*object
, *function
, *description
;
1195 CORE_ADDR string_addr
, object_addr
;
1199 if (!args
|| !*args
)
1201 "The 'print-object' command requires an argument (an Objective-C object)");
1204 expression_up expr
= parse_expression (args
);
1207 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1208 expr
.get (), &pc
, EVAL_NORMAL
);
1211 /* Validate the address for sanity. */
1212 object_addr
= value_as_long (object
);
1213 read_memory (object_addr
, &c
, 1);
1215 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1216 if (function
== NULL
)
1217 error (_("Unable to locate _NSPrintForDebugger in child process"));
1219 description
= call_function_by_hand (function
, NULL
, object
);
1221 string_addr
= value_as_long (description
);
1222 if (string_addr
== 0)
1223 error (_("object returns null description"));
1225 read_memory (string_addr
+ i
++, &c
, 1);
1228 { /* Read and print characters up to EOS. */
1230 printf_filtered ("%c", c
);
1231 read_memory (string_addr
+ i
++, &c
, 1);
1234 printf_filtered(_("<object returns empty description>"));
1235 printf_filtered ("\n");
1238 /* The data structure 'methcalls' is used to detect method calls (thru
1239 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1240 * and ultimately find the method being called.
1243 struct objc_methcall
{
1245 /* Return instance method to be called. */
1246 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1247 /* Start of pc range corresponding to method invocation. */
1249 /* End of pc range corresponding to method invocation. */
1253 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1254 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1255 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1256 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1258 static struct objc_methcall methcalls
[] = {
1259 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1260 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1261 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1262 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1263 { "_objc_getClass", NULL
, 0, 0},
1264 { "_objc_getMetaClass", NULL
, 0, 0}
1267 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1269 /* The following function, "find_objc_msgsend", fills in the data
1270 * structure "objc_msgs" by finding the addresses of each of the
1271 * (currently four) functions that it holds (of which objc_msgSend is
1272 * the first). This must be called each time symbols are loaded, in
1273 * case the functions have moved for some reason.
1277 find_objc_msgsend (void)
1281 for (i
= 0; i
< nmethcalls
; i
++)
1283 struct bound_minimal_symbol func
;
1285 /* Try both with and without underscore. */
1286 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1287 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1289 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1291 if (func
.minsym
== NULL
)
1293 methcalls
[i
].begin
= 0;
1294 methcalls
[i
].end
= 0;
1298 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1299 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1303 /* find_objc_msgcall (replaces pc_off_limits)
1305 * ALL that this function now does is to determine whether the input
1306 * address ("pc") is the address of one of the Objective-C message
1307 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1308 * if so, it returns the address of the method that will be called.
1310 * The old function "pc_off_limits" used to do a lot of other things
1311 * in addition, such as detecting shared library jump stubs and
1312 * returning the address of the shlib function that would be called.
1313 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1314 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1315 * dependent modules.
1319 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1325 if (f (pc
, new_pc
) == 0)
1328 catch (const gdb_exception
&ex
)
1330 exception_fprintf (gdb_stderr
, ex
,
1331 "Unable to determine target of "
1332 "Objective-C method call (ignoring):\n");
1339 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1343 find_objc_msgsend ();
1349 for (i
= 0; i
< nmethcalls
; i
++)
1350 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1352 if (methcalls
[i
].stop_at
!= NULL
)
1353 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1362 void _initialize_objc_language ();
1364 _initialize_objc_language ()
1366 add_info ("selectors", info_selectors_command
,
1367 _("All Objective-C selectors, or those matching REGEXP."));
1368 add_info ("classes", info_classes_command
,
1369 _("All Objective-C classes, or those matching REGEXP."));
1370 add_com ("print-object", class_vars
, print_object_command
,
1371 _("Ask an Objective-C object to print itself."));
1372 add_com_alias ("po", "print-object", class_vars
, 1);
1376 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1377 struct objc_method
*method
)
1379 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1381 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1382 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1383 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1386 static unsigned long
1387 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1389 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1391 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1395 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1396 unsigned long num
, struct objc_method
*method
)
1398 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1399 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1403 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1404 struct objc_object
*object
)
1406 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1408 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1412 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1413 struct objc_super
*super
)
1415 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1417 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1418 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1422 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1423 struct objc_class
*theclass
)
1425 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1427 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1428 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1429 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1430 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1431 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1432 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1434 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1435 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1436 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1437 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1441 find_implementation_from_class (struct gdbarch
*gdbarch
,
1442 CORE_ADDR theclass
, CORE_ADDR sel
)
1444 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1445 CORE_ADDR subclass
= theclass
;
1447 while (subclass
!= 0)
1450 struct objc_class class_str
;
1451 unsigned mlistnum
= 0;
1453 read_objc_class (gdbarch
, subclass
, &class_str
);
1458 unsigned long nmethods
;
1461 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1467 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1469 for (i
= 0; i
< nmethods
; i
++)
1471 struct objc_method meth_str
;
1473 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1475 if (meth_str
.name
== sel
)
1476 /* FIXME: hppa arch was doing a pointer dereference
1477 here. There needs to be a better way to do that. */
1478 return meth_str
.imp
;
1482 subclass
= class_str
.super_class
;
1489 find_implementation (struct gdbarch
*gdbarch
,
1490 CORE_ADDR object
, CORE_ADDR sel
)
1492 struct objc_object ostr
;
1496 read_objc_object (gdbarch
, object
, &ostr
);
1500 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1504 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1506 struct frame_info
*frame
= get_current_frame ();
1507 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1508 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1514 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1515 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1517 res
= find_implementation (gdbarch
, object
, sel
);
1526 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1528 struct frame_info
*frame
= get_current_frame ();
1529 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1530 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1536 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1537 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1539 res
= find_implementation (gdbarch
, object
, sel
);
1548 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1550 struct frame_info
*frame
= get_current_frame ();
1551 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1552 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1554 struct objc_super sstr
;
1560 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1561 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1563 read_objc_super (gdbarch
, super
, &sstr
);
1564 if (sstr
.theclass
== 0)
1567 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1576 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1578 struct frame_info
*frame
= get_current_frame ();
1579 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1580 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1582 struct objc_super sstr
;
1588 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1589 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1591 read_objc_super (gdbarch
, super
, &sstr
);
1592 if (sstr
.theclass
== 0)
1595 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);