1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2020 Free Software Foundation, Inc.
5 Contributed by Apple Computer, Inc.
6 Written by Michael Snyder.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
27 #include "parser-defs.h"
31 #include "objc-lang.h"
32 #include "complaints.h"
36 #include "target.h" /* for target_has_execution */
40 #include "gdb_regex.h"
45 #include "cli/cli-utils.h"
56 CORE_ADDR super_class
;
78 static const struct objfile_key
<unsigned int> objc_objfile_data
;
80 /* Lookup a structure type named "struct NAME", visible in lexical
81 block BLOCK. If NOERR is nonzero, return zero if NAME is not
85 lookup_struct_typedef (const char *name
, const struct block
*block
, int noerr
)
89 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
96 error (_("No struct type named %s."), name
);
98 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
103 error (_("This context has class, union or enum %s, not a struct."),
110 lookup_objc_class (struct gdbarch
*gdbarch
, const char *classname
)
112 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
113 struct value
* function
, *classval
;
115 if (! target_has_execution
)
117 /* Can't call into inferior to lookup class. */
121 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0).minsym
)
122 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
123 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym
)
124 function
= find_function_in_inferior("objc_lookup_class", NULL
);
127 complaint (_("no way to lookup Objective-C classes"));
131 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
132 classval
= value_coerce_array (classval
);
133 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
139 lookup_child_selector (struct gdbarch
*gdbarch
, const char *selname
)
141 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
142 struct value
* function
, *selstring
;
144 if (! target_has_execution
)
146 /* Can't call into inferior to lookup selector. */
150 if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym
)
151 function
= find_function_in_inferior("sel_getUid", NULL
);
152 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym
)
153 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
156 complaint (_("no way to lookup Objective-C selectors"));
160 selstring
= value_coerce_array (value_string (selname
,
161 strlen (selname
) + 1,
163 return value_as_long (call_function_by_hand (function
, NULL
, selstring
));
167 value_nsstring (struct gdbarch
*gdbarch
, char *ptr
, int len
)
169 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
170 struct value
*stringValue
[3];
171 struct value
*function
, *nsstringValue
;
175 if (!target_has_execution
)
176 return 0; /* Can't call into inferior to create NSString. */
178 stringValue
[2] = value_string(ptr
, len
, char_type
);
179 stringValue
[2] = value_coerce_array(stringValue
[2]);
180 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
181 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym
)
183 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
184 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
186 else if (lookup_minimal_symbol("istr", 0, 0).minsym
)
188 function
= find_function_in_inferior("istr", NULL
);
189 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
191 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym
)
194 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
195 type
= builtin_type (gdbarch
)->builtin_long
;
197 stringValue
[0] = value_from_longest
198 (type
, lookup_objc_class (gdbarch
, "NSString"));
199 stringValue
[1] = value_from_longest
200 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
201 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
);
204 error (_("NSString: internal error -- no way to create new NSString"));
206 sym
= lookup_struct_typedef("NSString", 0, 1);
208 sym
= lookup_struct_typedef("NXString", 0, 1);
210 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
212 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
214 deprecated_set_value_type (nsstringValue
, type
);
215 return nsstringValue
;
218 /* Objective-C name demangling. */
221 objc_demangle (const char *mangled
, int options
)
223 char *demangled
, *cp
;
225 if (mangled
[0] == '_' &&
226 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
229 cp
= demangled
= (char *) xmalloc (strlen (mangled
) + 2);
231 if (mangled
[1] == 'i')
232 *cp
++ = '-'; /* for instance method */
234 *cp
++ = '+'; /* for class method */
236 *cp
++ = '['; /* opening left brace */
237 strcpy(cp
, mangled
+3); /* Tack on the rest of the mangled name. */
239 while (*cp
&& *cp
== '_')
240 cp
++; /* Skip any initial underbars in class
243 cp
= strchr(cp
, '_');
244 if (!cp
) /* Find first non-initial underbar. */
246 xfree(demangled
); /* not mangled name */
249 if (cp
[1] == '_') /* Easy case: no category name. */
251 *cp
++ = ' '; /* Replace two '_' with one ' '. */
252 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
256 *cp
++ = '('; /* Less easy case: category name. */
257 cp
= strchr(cp
, '_');
260 xfree(demangled
); /* not mangled name */
264 *cp
++ = ' '; /* Overwriting 1st char of method name... */
265 strcpy(cp
, mangled
+ (cp
- demangled
)); /* Get it back. */
268 while (*cp
&& *cp
== '_')
269 cp
++; /* Skip any initial underbars in
274 *cp
= ':'; /* Replace remaining '_' with ':'. */
276 *cp
++ = ']'; /* closing right brace */
277 *cp
++ = 0; /* string terminator */
281 return NULL
; /* Not an objc mangled name. */
284 /* Determine if we are currently in the Objective-C dispatch function.
285 If so, get the address of the method function that the dispatcher
286 would call and use that as the function to step into instead. Also
287 skip over the trampoline for the function (if any). This is better
288 for the user since they are only interested in stepping into the
289 method function anyway. */
291 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
293 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
294 CORE_ADDR real_stop_pc
;
295 CORE_ADDR method_stop_pc
;
297 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
299 if (real_stop_pc
!= 0)
300 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
302 find_objc_msgcall (stop_pc
, &method_stop_pc
);
306 real_stop_pc
= gdbarch_skip_trampoline_code
307 (gdbarch
, frame
, method_stop_pc
);
308 if (real_stop_pc
== 0)
309 real_stop_pc
= method_stop_pc
;
316 /* Table mapping opcodes into strings for printing operators
317 and precedences of the operators. */
319 static const struct op_print objc_op_print_tab
[] =
321 {",", BINOP_COMMA
, PREC_COMMA
, 0},
322 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
323 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
324 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
325 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
326 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
327 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
328 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
329 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
330 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
331 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
332 {">", BINOP_GTR
, PREC_ORDER
, 0},
333 {"<", BINOP_LESS
, PREC_ORDER
, 0},
334 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
335 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
336 {"+", BINOP_ADD
, PREC_ADD
, 0},
337 {"-", BINOP_SUB
, PREC_ADD
, 0},
338 {"*", BINOP_MUL
, PREC_MUL
, 0},
339 {"/", BINOP_DIV
, PREC_MUL
, 0},
340 {"%", BINOP_REM
, PREC_MUL
, 0},
341 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
342 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
343 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
344 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
345 {"*", UNOP_IND
, PREC_PREFIX
, 0},
346 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
347 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
348 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
349 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
350 {NULL
, OP_NULL
, PREC_NULL
, 0}
353 static const char *objc_extensions
[] =
358 /* Constant data representing the Objective-C language. */
360 extern const struct language_data objc_language_data
=
362 "objective-c", /* Language name */
370 &exp_descriptor_standard
,
373 c_printchar
, /* Print a character constant */
374 c_printstr
, /* Function to print string constant */
376 c_print_typedef
, /* Print a typedef using appropriate syntax */
377 c_value_print_inner
, /* la_value_print_inner */
378 c_value_print
, /* Print a top-level value */
379 objc_skip_trampoline
, /* Language specific skip_trampoline */
380 "self", /* name_of_this */
381 false, /* la_store_sym_names_in_linkage_form_p */
382 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
383 NULL
, /* Language specific
384 class_name_from_physname */
385 objc_op_print_tab
, /* Expression operators for printing */
386 1, /* C-style arrays */
387 0, /* String lower bound */
388 default_word_break_characters
,
389 default_collect_symbol_completion_matches
,
390 c_watch_location_expression
,
391 NULL
, /* la_get_symbol_name_matcher */
395 "{...}" /* la_struct_too_deep_ellipsis */
398 /* Class representing the Objective-C language. */
400 class objc_language
: public language_defn
404 : language_defn (language_objc
, objc_language_data
)
407 /* See language.h. */
408 void language_arch_info (struct gdbarch
*gdbarch
,
409 struct language_arch_info
*lai
) const override
411 c_language_arch_info (gdbarch
, lai
);
414 /* See language.h. */
415 bool sniff_from_mangled_name (const char *mangled
,
416 char **demangled
) const override
418 *demangled
= objc_demangle (mangled
, 0);
419 return *demangled
!= NULL
;
422 /* See language.h. */
424 char *demangle (const char *mangled
, int options
) const override
426 return objc_demangle (mangled
, options
);
429 /* See language.h. */
431 void print_type (struct type
*type
, const char *varstring
,
432 struct ui_file
*stream
, int show
, int level
,
433 const struct type_print_options
*flags
) const override
435 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
439 /* Single instance of the class representing the Objective-C language. */
441 static objc_language objc_language_defn
;
445 * Following functions help construct Objective-C message calls.
448 struct selname
/* For parsing Objective-C. */
450 struct selname
*next
;
455 static int msglist_len
;
456 static struct selname
*selname_chain
;
457 static char *msglist_sel
;
462 struct selname
*newobj
= XNEW (struct selname
);
464 newobj
->next
= selname_chain
;
465 newobj
->msglist_len
= msglist_len
;
466 newobj
->msglist_sel
= msglist_sel
;
468 msglist_sel
= (char *)xmalloc(1);
470 selname_chain
= newobj
;
474 add_msglist(struct stoken
*str
, int addcolon
)
480 if (str
== 0) /* Unnamed arg, or... */
482 if (addcolon
== 0) /* variable number of args. */
495 len
= plen
+ strlen(msglist_sel
) + 2;
496 s
= (char *)xmalloc(len
);
497 strcpy(s
, msglist_sel
);
512 end_msglist (struct parser_state
*ps
)
514 int val
= msglist_len
;
515 struct selname
*sel
= selname_chain
;
516 char *p
= msglist_sel
;
519 selname_chain
= sel
->next
;
520 msglist_len
= sel
->msglist_len
;
521 msglist_sel
= sel
->msglist_sel
;
522 selid
= lookup_child_selector (ps
->gdbarch (), p
);
524 error (_("Can't find selector \"%s\""), p
);
525 write_exp_elt_longcst (ps
, selid
);
527 write_exp_elt_longcst (ps
, val
); /* Number of args */
534 * Function: specialcmp (const char *a, const char *b)
536 * Special strcmp: treats ']' and ' ' as end-of-string.
537 * Used for qsorting lists of objc methods (either by class or selector).
541 specialcmp (const char *a
, const char *b
)
543 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
549 if (*a
&& *a
!= ' ' && *a
!= ']')
550 return 1; /* a is longer therefore greater. */
551 if (*b
&& *b
!= ' ' && *b
!= ']')
552 return -1; /* a is shorter therefore lesser. */
553 return 0; /* a and b are identical. */
557 * Function: compare_selectors (const void *, const void *)
559 * Comparison function for use with qsort. Arguments are symbols or
560 * msymbols Compares selector part of objc method name alphabetically.
564 compare_selectors (const void *a
, const void *b
)
566 const char *aname
, *bname
;
568 aname
= (*(struct symbol
**) a
)->print_name ();
569 bname
= (*(struct symbol
**) b
)->print_name ();
570 if (aname
== NULL
|| bname
== NULL
)
571 error (_("internal: compare_selectors(1)"));
573 aname
= strchr(aname
, ' ');
574 bname
= strchr(bname
, ' ');
575 if (aname
== NULL
|| bname
== NULL
)
576 error (_("internal: compare_selectors(2)"));
578 return specialcmp (aname
+1, bname
+1);
582 * Function: selectors_info (regexp, from_tty)
584 * Implements the "Info selectors" command. Takes an optional regexp
585 * arg. Lists all objective c selectors that match the regexp. Works
586 * by grepping thru all symbols for objective c methods. Output list
587 * is sorted and uniqued.
591 info_selectors_command (const char *regexp
, int from_tty
)
600 struct symbol
**sym_arr
;
604 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
607 if (*regexp
== '+' || *regexp
== '-')
608 { /* User wants only class methods or only instance methods. */
609 plusminus
= *regexp
++;
610 while (*regexp
== ' ' || *regexp
== '\t')
614 strcpy(myregexp
, ".*]");
617 /* Allow a few extra bytes because of the strcat below. */
618 if (sizeof (myregexp
) < strlen (regexp
) + 4)
619 error (_("Regexp is too long: %s"), regexp
);
620 strcpy(myregexp
, regexp
);
621 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
622 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
624 strcat(myregexp
, ".*]");
630 val
= re_comp (myregexp
);
632 error (_("Invalid regexp (%s): %s"), val
, regexp
);
635 /* First time thru is JUST to get max length and count. */
636 for (objfile
*objfile
: current_program_space
->objfiles ())
638 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
641 name
= msymbol
->natural_name ();
643 && (name
[0] == '-' || name
[0] == '+')
644 && name
[1] == '[') /* Got a method name. */
646 /* Filter for class/instance methods. */
647 if (plusminus
&& name
[0] != plusminus
)
649 /* Find selector part. */
650 name
= (char *) strchr (name
+2, ' ');
653 complaint (_("Bad method name '%s'"),
654 msymbol
->natural_name ());
657 if (regexp
== NULL
|| re_exec(++name
) != 0)
659 const char *mystart
= name
;
660 const char *myend
= strchr (mystart
, ']');
662 if (myend
&& (myend
- mystart
> maxlen
))
663 maxlen
= myend
- mystart
; /* Get longest selector. */
671 printf_filtered (_("Selectors matching \"%s\":\n\n"),
672 regexp
? regexp
: "*");
674 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
676 for (objfile
*objfile
: current_program_space
->objfiles ())
678 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
681 name
= msymbol
->natural_name ();
683 (name
[0] == '-' || name
[0] == '+') &&
684 name
[1] == '[') /* Got a method name. */
686 /* Filter for class/instance methods. */
687 if (plusminus
&& name
[0] != plusminus
)
689 /* Find selector part. */
690 name
= (char *) strchr(name
+2, ' ');
691 if (regexp
== NULL
|| re_exec(++name
) != 0)
692 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
697 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
699 /* Prevent compare on first iteration. */
701 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
706 name
= sym_arr
[ix
]->natural_name ();
707 name
= strchr (name
, ' ') + 1;
708 if (p
[0] && specialcmp(name
, p
) == 0)
709 continue; /* Seen this one already (not unique). */
711 /* Copy selector part. */
712 while (*name
&& *name
!= ']')
715 /* Print in columns. */
716 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
721 printf_filtered (_("No selectors matching \"%s\"\n"),
722 regexp
? regexp
: "*");
726 * Function: compare_classes (const void *, const void *)
728 * Comparison function for use with qsort. Arguments are symbols or
729 * msymbols Compares class part of objc method name alphabetically.
733 compare_classes (const void *a
, const void *b
)
735 const char *aname
, *bname
;
737 aname
= (*(struct symbol
**) a
)->print_name ();
738 bname
= (*(struct symbol
**) b
)->print_name ();
739 if (aname
== NULL
|| bname
== NULL
)
740 error (_("internal: compare_classes(1)"));
742 return specialcmp (aname
+1, bname
+1);
746 * Function: classes_info(regexp, from_tty)
748 * Implements the "info classes" command for objective c classes.
749 * Lists all objective c classes that match the optional regexp.
750 * Works by grepping thru the list of objective c methods. List will
751 * be sorted and uniqued (since one class may have many methods).
752 * BUGS: will not list a class that has no methods.
756 info_classes_command (const char *regexp
, int from_tty
)
765 struct symbol
**sym_arr
;
768 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
771 /* Allow a few extra bytes because of the strcat below. */
772 if (sizeof (myregexp
) < strlen (regexp
) + 4)
773 error (_("Regexp is too long: %s"), regexp
);
774 strcpy(myregexp
, regexp
);
775 if (myregexp
[strlen(myregexp
) - 1] == '$')
776 /* In the method name, the end of the class name is marked by ' '. */
777 myregexp
[strlen(myregexp
) - 1] = ' ';
779 strcat(myregexp
, ".* ");
784 val
= re_comp (myregexp
);
786 error (_("Invalid regexp (%s): %s"), val
, regexp
);
789 /* First time thru is JUST to get max length and count. */
790 for (objfile
*objfile
: current_program_space
->objfiles ())
792 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
795 name
= msymbol
->natural_name ();
797 (name
[0] == '-' || name
[0] == '+') &&
798 name
[1] == '[') /* Got a method name. */
799 if (regexp
== NULL
|| re_exec(name
+2) != 0)
801 /* Compute length of classname part. */
802 const char *mystart
= name
+ 2;
803 const char *myend
= strchr (mystart
, ' ');
805 if (myend
&& (myend
- mystart
> maxlen
))
806 maxlen
= myend
- mystart
;
813 printf_filtered (_("Classes matching \"%s\":\n\n"),
814 regexp
? regexp
: "*");
815 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
817 for (objfile
*objfile
: current_program_space
->objfiles ())
819 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
822 name
= msymbol
->natural_name ();
824 (name
[0] == '-' || name
[0] == '+') &&
825 name
[1] == '[') /* Got a method name. */
826 if (regexp
== NULL
|| re_exec(name
+2) != 0)
827 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
831 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
833 /* Prevent compare on first iteration. */
835 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
840 name
= sym_arr
[ix
]->natural_name ();
842 if (p
[0] && specialcmp(name
, p
) == 0)
843 continue; /* Seen this one already (not unique). */
845 /* Copy class part of method name. */
846 while (*name
&& *name
!= ' ')
849 /* Print in columns. */
850 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
855 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
859 parse_selector (char *method
, char **selector
)
865 char *nselector
= NULL
;
867 gdb_assert (selector
!= NULL
);
871 s1
= skip_spaces (s1
);
877 s1
= skip_spaces (s1
);
884 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
886 else if (isspace (*s2
))
888 else if ((*s2
== '\0') || (*s2
== '\''))
896 s2
= skip_spaces (s2
);
901 s2
= skip_spaces (s2
);
904 if (selector
!= NULL
)
905 *selector
= nselector
;
911 parse_method (char *method
, char *type
, char **theclass
,
912 char **category
, char **selector
)
920 char *ncategory
= NULL
;
921 char *nselector
= NULL
;
923 gdb_assert (type
!= NULL
);
924 gdb_assert (theclass
!= NULL
);
925 gdb_assert (category
!= NULL
);
926 gdb_assert (selector
!= NULL
);
930 s1
= skip_spaces (s1
);
936 s1
= skip_spaces (s1
);
938 if ((s1
[0] == '+') || (s1
[0] == '-'))
941 s1
= skip_spaces (s1
);
948 while (isalnum (*s1
) || (*s1
== '_'))
952 s2
= skip_spaces (s2
);
957 s2
= skip_spaces (s2
);
959 while (isalnum (*s2
) || (*s2
== '_'))
964 /* Truncate the class name now that we're not using the open paren. */
972 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
974 else if (isspace (*s2
))
985 s2
= skip_spaces (s2
);
991 s2
= skip_spaces (s2
);
996 if (theclass
!= NULL
)
998 if (category
!= NULL
)
999 *category
= ncategory
;
1000 if (selector
!= NULL
)
1001 *selector
= nselector
;
1007 find_methods (char type
, const char *theclass
, const char *category
,
1008 const char *selector
,
1009 std::vector
<const char *> *symbol_names
)
1011 const char *symname
= NULL
;
1014 char *nclass
= NULL
;
1015 char *ncategory
= NULL
;
1016 char *nselector
= NULL
;
1018 static char *tmp
= NULL
;
1019 static unsigned int tmplen
= 0;
1021 gdb_assert (symbol_names
!= NULL
);
1023 for (objfile
*objfile
: current_program_space
->objfiles ())
1025 unsigned int *objc_csym
;
1027 /* The objfile_csym variable counts the number of ObjC methods
1028 that this objfile defines. We save that count as a private
1029 objfile data. If we have already determined that this objfile
1030 provides no ObjC methods, we can skip it entirely. */
1032 unsigned int objfile_csym
= 0;
1034 objc_csym
= objc_objfile_data
.get (objfile
);
1035 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1036 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1039 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1043 /* Check the symbol name first as this can be done entirely without
1044 sending any query to the target. */
1045 symname
= msymbol
->natural_name ();
1046 if (symname
== NULL
)
1049 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1050 /* Not a method name. */
1055 /* Now that thinks are a bit sane, clean up the symname. */
1056 while ((strlen (symname
) + 1) >= tmplen
)
1058 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1059 tmp
= (char *) xrealloc (tmp
, tmplen
);
1061 strcpy (tmp
, symname
);
1063 if (parse_method (tmp
, &ntype
, &nclass
,
1064 &ncategory
, &nselector
) == NULL
)
1067 if ((type
!= '\0') && (ntype
!= type
))
1070 if ((theclass
!= NULL
)
1071 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1074 if ((category
!= NULL
) &&
1075 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1078 if ((selector
!= NULL
) &&
1079 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1082 symbol_names
->push_back (symname
);
1085 if (objc_csym
== NULL
)
1086 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1088 /* Count of ObjC methods in this objfile should be constant. */
1089 gdb_assert (*objc_csym
== objfile_csym
);
1093 /* Uniquify a vector of strings. */
1096 uniquify_strings (std::vector
<const char *> *strings
)
1098 if (strings
->empty ())
1101 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1102 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1107 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1109 * Input: a string representing a selector
1110 * a pointer to an array of symbol pointers
1111 * possibly a pointer to a symbol found by the caller.
1113 * Output: number of methods that implement that selector. Side
1114 * effects: The array of symbol pointers is filled with matching syms.
1116 * By analogy with function "find_methods" (symtab.c), builds a list
1117 * of symbols matching the ambiguous input, so that "decode_line_2"
1118 * (symtab.c) can list them and ask the user to choose one or more.
1119 * In this case the matches are objective c methods
1120 * ("implementations") matching an objective c selector.
1122 * Note that it is possible for a normal (c-style) function to have
1123 * the same name as an objective c selector. To prevent the selector
1124 * from eclipsing the function, we allow the caller (decode_line_1) to
1125 * search for such a function first, and if it finds one, pass it in
1126 * to us. We will then integrate it into the list. We also search
1127 * for one here, among the minsyms.
1129 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1130 * into two parts: debuggable (struct symbol) syms, and
1131 * non_debuggable (struct minimal_symbol) syms. The debuggable
1132 * ones will come first, before NUM_DEBUGGABLE (which will thus
1133 * be the index of the first non-debuggable one).
1137 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1140 char *theclass
= NULL
;
1141 char *category
= NULL
;
1142 char *selector
= NULL
;
1147 int selector_case
= 0;
1149 gdb_assert (symbol_names
!= NULL
);
1151 buf
= (char *) alloca (strlen (method
) + 1);
1152 strcpy (buf
, method
);
1153 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1157 strcpy (buf
, method
);
1158 tmp
= parse_selector (buf
, &selector
);
1166 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1168 /* If we hit the "selector" case, and we found some methods, then
1169 add the selector itself as a symbol, if it exists. */
1170 if (selector_case
&& !symbol_names
->empty ())
1172 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1176 symbol_names
->push_back (sym
->natural_name ());
1179 struct bound_minimal_symbol msym
1180 = lookup_minimal_symbol (selector
, 0, 0);
1182 if (msym
.minsym
!= NULL
)
1183 symbol_names
->push_back (msym
.minsym
->natural_name ());
1187 uniquify_strings (symbol_names
);
1189 return method
+ (tmp
- buf
);
1193 print_object_command (const char *args
, int from_tty
)
1195 struct value
*object
, *function
, *description
;
1196 CORE_ADDR string_addr
, object_addr
;
1200 if (!args
|| !*args
)
1202 "The 'print-object' command requires an argument (an Objective-C object)");
1205 expression_up expr
= parse_expression (args
);
1208 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1209 expr
.get (), &pc
, EVAL_NORMAL
);
1212 /* Validate the address for sanity. */
1213 object_addr
= value_as_long (object
);
1214 read_memory (object_addr
, &c
, 1);
1216 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1217 if (function
== NULL
)
1218 error (_("Unable to locate _NSPrintForDebugger in child process"));
1220 description
= call_function_by_hand (function
, NULL
, object
);
1222 string_addr
= value_as_long (description
);
1223 if (string_addr
== 0)
1224 error (_("object returns null description"));
1226 read_memory (string_addr
+ i
++, &c
, 1);
1229 { /* Read and print characters up to EOS. */
1231 printf_filtered ("%c", c
);
1232 read_memory (string_addr
+ i
++, &c
, 1);
1235 printf_filtered(_("<object returns empty description>"));
1236 printf_filtered ("\n");
1239 /* The data structure 'methcalls' is used to detect method calls (thru
1240 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1241 * and ultimately find the method being called.
1244 struct objc_methcall
{
1246 /* Return instance method to be called. */
1247 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1248 /* Start of pc range corresponding to method invocation. */
1250 /* End of pc range corresponding to method invocation. */
1254 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1255 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1256 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1257 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1259 static struct objc_methcall methcalls
[] = {
1260 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1261 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1262 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1263 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1264 { "_objc_getClass", NULL
, 0, 0},
1265 { "_objc_getMetaClass", NULL
, 0, 0}
1268 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1270 /* The following function, "find_objc_msgsend", fills in the data
1271 * structure "objc_msgs" by finding the addresses of each of the
1272 * (currently four) functions that it holds (of which objc_msgSend is
1273 * the first). This must be called each time symbols are loaded, in
1274 * case the functions have moved for some reason.
1278 find_objc_msgsend (void)
1282 for (i
= 0; i
< nmethcalls
; i
++)
1284 struct bound_minimal_symbol func
;
1286 /* Try both with and without underscore. */
1287 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1288 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1290 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1292 if (func
.minsym
== NULL
)
1294 methcalls
[i
].begin
= 0;
1295 methcalls
[i
].end
= 0;
1299 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1300 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1304 /* find_objc_msgcall (replaces pc_off_limits)
1306 * ALL that this function now does is to determine whether the input
1307 * address ("pc") is the address of one of the Objective-C message
1308 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1309 * if so, it returns the address of the method that will be called.
1311 * The old function "pc_off_limits" used to do a lot of other things
1312 * in addition, such as detecting shared library jump stubs and
1313 * returning the address of the shlib function that would be called.
1314 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1315 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1316 * dependent modules.
1320 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1326 if (f (pc
, new_pc
) == 0)
1329 catch (const gdb_exception
&ex
)
1331 exception_fprintf (gdb_stderr
, ex
,
1332 "Unable to determine target of "
1333 "Objective-C method call (ignoring):\n");
1340 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1344 find_objc_msgsend ();
1350 for (i
= 0; i
< nmethcalls
; i
++)
1351 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1353 if (methcalls
[i
].stop_at
!= NULL
)
1354 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1363 void _initialize_objc_language ();
1365 _initialize_objc_language ()
1367 add_info ("selectors", info_selectors_command
,
1368 _("All Objective-C selectors, or those matching REGEXP."));
1369 add_info ("classes", info_classes_command
,
1370 _("All Objective-C classes, or those matching REGEXP."));
1371 add_com ("print-object", class_vars
, print_object_command
,
1372 _("Ask an Objective-C object to print itself."));
1373 add_com_alias ("po", "print-object", class_vars
, 1);
1377 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1378 struct objc_method
*method
)
1380 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1382 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1383 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1384 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1387 static unsigned long
1388 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1390 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1392 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1396 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1397 unsigned long num
, struct objc_method
*method
)
1399 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1400 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1404 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1405 struct objc_object
*object
)
1407 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1409 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1413 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1414 struct objc_super
*super
)
1416 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1418 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1419 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1423 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1424 struct objc_class
*theclass
)
1426 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1428 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1429 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1430 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1431 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1432 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1433 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1435 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1436 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1437 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1438 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1442 find_implementation_from_class (struct gdbarch
*gdbarch
,
1443 CORE_ADDR theclass
, CORE_ADDR sel
)
1445 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1446 CORE_ADDR subclass
= theclass
;
1448 while (subclass
!= 0)
1451 struct objc_class class_str
;
1452 unsigned mlistnum
= 0;
1454 read_objc_class (gdbarch
, subclass
, &class_str
);
1459 unsigned long nmethods
;
1462 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1468 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1470 for (i
= 0; i
< nmethods
; i
++)
1472 struct objc_method meth_str
;
1474 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1476 if (meth_str
.name
== sel
)
1477 /* FIXME: hppa arch was doing a pointer dereference
1478 here. There needs to be a better way to do that. */
1479 return meth_str
.imp
;
1483 subclass
= class_str
.super_class
;
1490 find_implementation (struct gdbarch
*gdbarch
,
1491 CORE_ADDR object
, CORE_ADDR sel
)
1493 struct objc_object ostr
;
1497 read_objc_object (gdbarch
, object
, &ostr
);
1501 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1505 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1507 struct frame_info
*frame
= get_current_frame ();
1508 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1509 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1515 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1516 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1518 res
= find_implementation (gdbarch
, object
, sel
);
1527 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1529 struct frame_info
*frame
= get_current_frame ();
1530 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1531 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1537 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1538 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1540 res
= find_implementation (gdbarch
, object
, sel
);
1549 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1551 struct frame_info
*frame
= get_current_frame ();
1552 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1553 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1555 struct objc_super sstr
;
1561 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1562 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1564 read_objc_super (gdbarch
, super
, &sstr
);
1565 if (sstr
.theclass
== 0)
1568 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1577 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1579 struct frame_info
*frame
= get_current_frame ();
1580 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1581 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1583 struct objc_super sstr
;
1589 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1590 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1592 read_objc_super (gdbarch
, super
, &sstr
);
1593 if (sstr
.theclass
== 0)
1596 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);