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 c_watch_location_expression
,
357 "{...}" /* la_struct_too_deep_ellipsis */
360 /* Class representing the Objective-C language. */
362 class objc_language
: public language_defn
366 : language_defn (language_objc
, objc_language_data
)
369 /* See language.h. */
370 void language_arch_info (struct gdbarch
*gdbarch
,
371 struct language_arch_info
*lai
) const override
373 c_language_arch_info (gdbarch
, lai
);
376 /* See language.h. */
377 bool sniff_from_mangled_name (const char *mangled
,
378 char **demangled
) const override
380 *demangled
= objc_demangle (mangled
, 0);
381 return *demangled
!= NULL
;
384 /* See language.h. */
386 char *demangle (const char *mangled
, int options
) const override
388 return objc_demangle (mangled
, options
);
391 /* See language.h. */
393 void print_type (struct type
*type
, const char *varstring
,
394 struct ui_file
*stream
, int show
, int level
,
395 const struct type_print_options
*flags
) const override
397 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
400 /* See language.h. */
402 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
403 CORE_ADDR stop_pc
) const override
405 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
406 CORE_ADDR real_stop_pc
;
407 CORE_ADDR method_stop_pc
;
409 /* Determine if we are currently in the Objective-C dispatch function.
410 If so, get the address of the method function that the dispatcher
411 would call and use that as the function to step into instead. Also
412 skip over the trampoline for the function (if any). This is better
413 for the user since they are only interested in stepping into the
414 method function anyway. */
416 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
418 if (real_stop_pc
!= 0)
419 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
421 find_objc_msgcall (stop_pc
, &method_stop_pc
);
425 real_stop_pc
= gdbarch_skip_trampoline_code
426 (gdbarch
, frame
, method_stop_pc
);
427 if (real_stop_pc
== 0)
428 real_stop_pc
= method_stop_pc
;
435 /* Single instance of the class representing the Objective-C language. */
437 static objc_language objc_language_defn
;
441 * Following functions help construct Objective-C message calls.
444 struct selname
/* For parsing Objective-C. */
446 struct selname
*next
;
451 static int msglist_len
;
452 static struct selname
*selname_chain
;
453 static char *msglist_sel
;
458 struct selname
*newobj
= XNEW (struct selname
);
460 newobj
->next
= selname_chain
;
461 newobj
->msglist_len
= msglist_len
;
462 newobj
->msglist_sel
= msglist_sel
;
464 msglist_sel
= (char *)xmalloc(1);
466 selname_chain
= newobj
;
470 add_msglist(struct stoken
*str
, int addcolon
)
476 if (str
== 0) /* Unnamed arg, or... */
478 if (addcolon
== 0) /* variable number of args. */
491 len
= plen
+ strlen(msglist_sel
) + 2;
492 s
= (char *)xmalloc(len
);
493 strcpy(s
, msglist_sel
);
508 end_msglist (struct parser_state
*ps
)
510 int val
= msglist_len
;
511 struct selname
*sel
= selname_chain
;
512 char *p
= msglist_sel
;
515 selname_chain
= sel
->next
;
516 msglist_len
= sel
->msglist_len
;
517 msglist_sel
= sel
->msglist_sel
;
518 selid
= lookup_child_selector (ps
->gdbarch (), p
);
520 error (_("Can't find selector \"%s\""), p
);
521 write_exp_elt_longcst (ps
, selid
);
523 write_exp_elt_longcst (ps
, val
); /* Number of args */
530 * Function: specialcmp (const char *a, const char *b)
532 * Special strcmp: treats ']' and ' ' as end-of-string.
533 * Used for qsorting lists of objc methods (either by class or selector).
537 specialcmp (const char *a
, const char *b
)
539 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
545 if (*a
&& *a
!= ' ' && *a
!= ']')
546 return 1; /* a is longer therefore greater. */
547 if (*b
&& *b
!= ' ' && *b
!= ']')
548 return -1; /* a is shorter therefore lesser. */
549 return 0; /* a and b are identical. */
553 * Function: compare_selectors (const void *, const void *)
555 * Comparison function for use with qsort. Arguments are symbols or
556 * msymbols Compares selector part of objc method name alphabetically.
560 compare_selectors (const void *a
, const void *b
)
562 const char *aname
, *bname
;
564 aname
= (*(struct symbol
**) a
)->print_name ();
565 bname
= (*(struct symbol
**) b
)->print_name ();
566 if (aname
== NULL
|| bname
== NULL
)
567 error (_("internal: compare_selectors(1)"));
569 aname
= strchr(aname
, ' ');
570 bname
= strchr(bname
, ' ');
571 if (aname
== NULL
|| bname
== NULL
)
572 error (_("internal: compare_selectors(2)"));
574 return specialcmp (aname
+1, bname
+1);
578 * Function: selectors_info (regexp, from_tty)
580 * Implements the "Info selectors" command. Takes an optional regexp
581 * arg. Lists all objective c selectors that match the regexp. Works
582 * by grepping thru all symbols for objective c methods. Output list
583 * is sorted and uniqued.
587 info_selectors_command (const char *regexp
, int from_tty
)
596 struct symbol
**sym_arr
;
600 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
603 if (*regexp
== '+' || *regexp
== '-')
604 { /* User wants only class methods or only instance methods. */
605 plusminus
= *regexp
++;
606 while (*regexp
== ' ' || *regexp
== '\t')
610 strcpy(myregexp
, ".*]");
613 /* Allow a few extra bytes because of the strcat below. */
614 if (sizeof (myregexp
) < strlen (regexp
) + 4)
615 error (_("Regexp is too long: %s"), regexp
);
616 strcpy(myregexp
, regexp
);
617 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
618 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
620 strcat(myregexp
, ".*]");
626 val
= re_comp (myregexp
);
628 error (_("Invalid regexp (%s): %s"), val
, regexp
);
631 /* First time thru is JUST to get max length and count. */
632 for (objfile
*objfile
: current_program_space
->objfiles ())
634 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
637 name
= msymbol
->natural_name ();
639 && (name
[0] == '-' || name
[0] == '+')
640 && name
[1] == '[') /* Got a method name. */
642 /* Filter for class/instance methods. */
643 if (plusminus
&& name
[0] != plusminus
)
645 /* Find selector part. */
646 name
= (char *) strchr (name
+2, ' ');
649 complaint (_("Bad method name '%s'"),
650 msymbol
->natural_name ());
653 if (regexp
== NULL
|| re_exec(++name
) != 0)
655 const char *mystart
= name
;
656 const char *myend
= strchr (mystart
, ']');
658 if (myend
&& (myend
- mystart
> maxlen
))
659 maxlen
= myend
- mystart
; /* Get longest selector. */
667 printf_filtered (_("Selectors matching \"%s\":\n\n"),
668 regexp
? regexp
: "*");
670 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
672 for (objfile
*objfile
: current_program_space
->objfiles ())
674 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
677 name
= msymbol
->natural_name ();
679 (name
[0] == '-' || name
[0] == '+') &&
680 name
[1] == '[') /* Got a method name. */
682 /* Filter for class/instance methods. */
683 if (plusminus
&& name
[0] != plusminus
)
685 /* Find selector part. */
686 name
= (char *) strchr(name
+2, ' ');
687 if (regexp
== NULL
|| re_exec(++name
) != 0)
688 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
693 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
695 /* Prevent compare on first iteration. */
697 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
702 name
= sym_arr
[ix
]->natural_name ();
703 name
= strchr (name
, ' ') + 1;
704 if (p
[0] && specialcmp(name
, p
) == 0)
705 continue; /* Seen this one already (not unique). */
707 /* Copy selector part. */
708 while (*name
&& *name
!= ']')
711 /* Print in columns. */
712 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
717 printf_filtered (_("No selectors matching \"%s\"\n"),
718 regexp
? regexp
: "*");
722 * Function: compare_classes (const void *, const void *)
724 * Comparison function for use with qsort. Arguments are symbols or
725 * msymbols Compares class part of objc method name alphabetically.
729 compare_classes (const void *a
, const void *b
)
731 const char *aname
, *bname
;
733 aname
= (*(struct symbol
**) a
)->print_name ();
734 bname
= (*(struct symbol
**) b
)->print_name ();
735 if (aname
== NULL
|| bname
== NULL
)
736 error (_("internal: compare_classes(1)"));
738 return specialcmp (aname
+1, bname
+1);
742 * Function: classes_info(regexp, from_tty)
744 * Implements the "info classes" command for objective c classes.
745 * Lists all objective c classes that match the optional regexp.
746 * Works by grepping thru the list of objective c methods. List will
747 * be sorted and uniqued (since one class may have many methods).
748 * BUGS: will not list a class that has no methods.
752 info_classes_command (const char *regexp
, int from_tty
)
761 struct symbol
**sym_arr
;
764 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
767 /* Allow a few extra bytes because of the strcat below. */
768 if (sizeof (myregexp
) < strlen (regexp
) + 4)
769 error (_("Regexp is too long: %s"), regexp
);
770 strcpy(myregexp
, regexp
);
771 if (myregexp
[strlen(myregexp
) - 1] == '$')
772 /* In the method name, the end of the class name is marked by ' '. */
773 myregexp
[strlen(myregexp
) - 1] = ' ';
775 strcat(myregexp
, ".* ");
780 val
= re_comp (myregexp
);
782 error (_("Invalid regexp (%s): %s"), val
, regexp
);
785 /* First time thru is JUST to get max length and count. */
786 for (objfile
*objfile
: current_program_space
->objfiles ())
788 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
791 name
= msymbol
->natural_name ();
793 (name
[0] == '-' || name
[0] == '+') &&
794 name
[1] == '[') /* Got a method name. */
795 if (regexp
== NULL
|| re_exec(name
+2) != 0)
797 /* Compute length of classname part. */
798 const char *mystart
= name
+ 2;
799 const char *myend
= strchr (mystart
, ' ');
801 if (myend
&& (myend
- mystart
> maxlen
))
802 maxlen
= myend
- mystart
;
809 printf_filtered (_("Classes matching \"%s\":\n\n"),
810 regexp
? regexp
: "*");
811 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
813 for (objfile
*objfile
: current_program_space
->objfiles ())
815 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
818 name
= msymbol
->natural_name ();
820 (name
[0] == '-' || name
[0] == '+') &&
821 name
[1] == '[') /* Got a method name. */
822 if (regexp
== NULL
|| re_exec(name
+2) != 0)
823 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
827 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
829 /* Prevent compare on first iteration. */
831 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
836 name
= sym_arr
[ix
]->natural_name ();
838 if (p
[0] && specialcmp(name
, p
) == 0)
839 continue; /* Seen this one already (not unique). */
841 /* Copy class part of method name. */
842 while (*name
&& *name
!= ' ')
845 /* Print in columns. */
846 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
851 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
855 parse_selector (char *method
, char **selector
)
861 char *nselector
= NULL
;
863 gdb_assert (selector
!= NULL
);
867 s1
= skip_spaces (s1
);
873 s1
= skip_spaces (s1
);
880 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
882 else if (isspace (*s2
))
884 else if ((*s2
== '\0') || (*s2
== '\''))
892 s2
= skip_spaces (s2
);
897 s2
= skip_spaces (s2
);
900 if (selector
!= NULL
)
901 *selector
= nselector
;
907 parse_method (char *method
, char *type
, char **theclass
,
908 char **category
, char **selector
)
916 char *ncategory
= NULL
;
917 char *nselector
= NULL
;
919 gdb_assert (type
!= NULL
);
920 gdb_assert (theclass
!= NULL
);
921 gdb_assert (category
!= NULL
);
922 gdb_assert (selector
!= NULL
);
926 s1
= skip_spaces (s1
);
932 s1
= skip_spaces (s1
);
934 if ((s1
[0] == '+') || (s1
[0] == '-'))
937 s1
= skip_spaces (s1
);
944 while (isalnum (*s1
) || (*s1
== '_'))
948 s2
= skip_spaces (s2
);
953 s2
= skip_spaces (s2
);
955 while (isalnum (*s2
) || (*s2
== '_'))
960 /* Truncate the class name now that we're not using the open paren. */
968 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
970 else if (isspace (*s2
))
981 s2
= skip_spaces (s2
);
987 s2
= skip_spaces (s2
);
992 if (theclass
!= NULL
)
994 if (category
!= NULL
)
995 *category
= ncategory
;
996 if (selector
!= NULL
)
997 *selector
= nselector
;
1003 find_methods (char type
, const char *theclass
, const char *category
,
1004 const char *selector
,
1005 std::vector
<const char *> *symbol_names
)
1007 const char *symname
= NULL
;
1010 char *nclass
= NULL
;
1011 char *ncategory
= NULL
;
1012 char *nselector
= NULL
;
1014 static char *tmp
= NULL
;
1015 static unsigned int tmplen
= 0;
1017 gdb_assert (symbol_names
!= NULL
);
1019 for (objfile
*objfile
: current_program_space
->objfiles ())
1021 unsigned int *objc_csym
;
1023 /* The objfile_csym variable counts the number of ObjC methods
1024 that this objfile defines. We save that count as a private
1025 objfile data. If we have already determined that this objfile
1026 provides no ObjC methods, we can skip it entirely. */
1028 unsigned int objfile_csym
= 0;
1030 objc_csym
= objc_objfile_data
.get (objfile
);
1031 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1032 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1035 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1039 /* Check the symbol name first as this can be done entirely without
1040 sending any query to the target. */
1041 symname
= msymbol
->natural_name ();
1042 if (symname
== NULL
)
1045 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1046 /* Not a method name. */
1051 /* Now that thinks are a bit sane, clean up the symname. */
1052 while ((strlen (symname
) + 1) >= tmplen
)
1054 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1055 tmp
= (char *) xrealloc (tmp
, tmplen
);
1057 strcpy (tmp
, symname
);
1059 if (parse_method (tmp
, &ntype
, &nclass
,
1060 &ncategory
, &nselector
) == NULL
)
1063 if ((type
!= '\0') && (ntype
!= type
))
1066 if ((theclass
!= NULL
)
1067 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1070 if ((category
!= NULL
) &&
1071 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1074 if ((selector
!= NULL
) &&
1075 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1078 symbol_names
->push_back (symname
);
1081 if (objc_csym
== NULL
)
1082 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1084 /* Count of ObjC methods in this objfile should be constant. */
1085 gdb_assert (*objc_csym
== objfile_csym
);
1089 /* Uniquify a vector of strings. */
1092 uniquify_strings (std::vector
<const char *> *strings
)
1094 if (strings
->empty ())
1097 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1098 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1103 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1105 * Input: a string representing a selector
1106 * a pointer to an array of symbol pointers
1107 * possibly a pointer to a symbol found by the caller.
1109 * Output: number of methods that implement that selector. Side
1110 * effects: The array of symbol pointers is filled with matching syms.
1112 * By analogy with function "find_methods" (symtab.c), builds a list
1113 * of symbols matching the ambiguous input, so that "decode_line_2"
1114 * (symtab.c) can list them and ask the user to choose one or more.
1115 * In this case the matches are objective c methods
1116 * ("implementations") matching an objective c selector.
1118 * Note that it is possible for a normal (c-style) function to have
1119 * the same name as an objective c selector. To prevent the selector
1120 * from eclipsing the function, we allow the caller (decode_line_1) to
1121 * search for such a function first, and if it finds one, pass it in
1122 * to us. We will then integrate it into the list. We also search
1123 * for one here, among the minsyms.
1125 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1126 * into two parts: debuggable (struct symbol) syms, and
1127 * non_debuggable (struct minimal_symbol) syms. The debuggable
1128 * ones will come first, before NUM_DEBUGGABLE (which will thus
1129 * be the index of the first non-debuggable one).
1133 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1136 char *theclass
= NULL
;
1137 char *category
= NULL
;
1138 char *selector
= NULL
;
1143 int selector_case
= 0;
1145 gdb_assert (symbol_names
!= NULL
);
1147 buf
= (char *) alloca (strlen (method
) + 1);
1148 strcpy (buf
, method
);
1149 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1153 strcpy (buf
, method
);
1154 tmp
= parse_selector (buf
, &selector
);
1162 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1164 /* If we hit the "selector" case, and we found some methods, then
1165 add the selector itself as a symbol, if it exists. */
1166 if (selector_case
&& !symbol_names
->empty ())
1168 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1172 symbol_names
->push_back (sym
->natural_name ());
1175 struct bound_minimal_symbol msym
1176 = lookup_minimal_symbol (selector
, 0, 0);
1178 if (msym
.minsym
!= NULL
)
1179 symbol_names
->push_back (msym
.minsym
->natural_name ());
1183 uniquify_strings (symbol_names
);
1185 return method
+ (tmp
- buf
);
1189 print_object_command (const char *args
, int from_tty
)
1191 struct value
*object
, *function
, *description
;
1192 CORE_ADDR string_addr
, object_addr
;
1196 if (!args
|| !*args
)
1198 "The 'print-object' command requires an argument (an Objective-C object)");
1201 expression_up expr
= parse_expression (args
);
1204 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1205 expr
.get (), &pc
, EVAL_NORMAL
);
1208 /* Validate the address for sanity. */
1209 object_addr
= value_as_long (object
);
1210 read_memory (object_addr
, &c
, 1);
1212 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1213 if (function
== NULL
)
1214 error (_("Unable to locate _NSPrintForDebugger in child process"));
1216 description
= call_function_by_hand (function
, NULL
, object
);
1218 string_addr
= value_as_long (description
);
1219 if (string_addr
== 0)
1220 error (_("object returns null description"));
1222 read_memory (string_addr
+ i
++, &c
, 1);
1225 { /* Read and print characters up to EOS. */
1227 printf_filtered ("%c", c
);
1228 read_memory (string_addr
+ i
++, &c
, 1);
1231 printf_filtered(_("<object returns empty description>"));
1232 printf_filtered ("\n");
1235 /* The data structure 'methcalls' is used to detect method calls (thru
1236 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1237 * and ultimately find the method being called.
1240 struct objc_methcall
{
1242 /* Return instance method to be called. */
1243 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1244 /* Start of pc range corresponding to method invocation. */
1246 /* End of pc range corresponding to method invocation. */
1250 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1251 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1252 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1253 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1255 static struct objc_methcall methcalls
[] = {
1256 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1257 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1258 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1259 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1260 { "_objc_getClass", NULL
, 0, 0},
1261 { "_objc_getMetaClass", NULL
, 0, 0}
1264 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1266 /* The following function, "find_objc_msgsend", fills in the data
1267 * structure "objc_msgs" by finding the addresses of each of the
1268 * (currently four) functions that it holds (of which objc_msgSend is
1269 * the first). This must be called each time symbols are loaded, in
1270 * case the functions have moved for some reason.
1274 find_objc_msgsend (void)
1278 for (i
= 0; i
< nmethcalls
; i
++)
1280 struct bound_minimal_symbol func
;
1282 /* Try both with and without underscore. */
1283 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1284 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1286 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1288 if (func
.minsym
== NULL
)
1290 methcalls
[i
].begin
= 0;
1291 methcalls
[i
].end
= 0;
1295 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1296 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1300 /* find_objc_msgcall (replaces pc_off_limits)
1302 * ALL that this function now does is to determine whether the input
1303 * address ("pc") is the address of one of the Objective-C message
1304 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1305 * if so, it returns the address of the method that will be called.
1307 * The old function "pc_off_limits" used to do a lot of other things
1308 * in addition, such as detecting shared library jump stubs and
1309 * returning the address of the shlib function that would be called.
1310 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1311 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1312 * dependent modules.
1316 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1322 if (f (pc
, new_pc
) == 0)
1325 catch (const gdb_exception
&ex
)
1327 exception_fprintf (gdb_stderr
, ex
,
1328 "Unable to determine target of "
1329 "Objective-C method call (ignoring):\n");
1336 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1340 find_objc_msgsend ();
1346 for (i
= 0; i
< nmethcalls
; i
++)
1347 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1349 if (methcalls
[i
].stop_at
!= NULL
)
1350 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1359 void _initialize_objc_language ();
1361 _initialize_objc_language ()
1363 add_info ("selectors", info_selectors_command
,
1364 _("All Objective-C selectors, or those matching REGEXP."));
1365 add_info ("classes", info_classes_command
,
1366 _("All Objective-C classes, or those matching REGEXP."));
1367 add_com ("print-object", class_vars
, print_object_command
,
1368 _("Ask an Objective-C object to print itself."));
1369 add_com_alias ("po", "print-object", class_vars
, 1);
1373 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1374 struct objc_method
*method
)
1376 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1378 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1379 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1380 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1383 static unsigned long
1384 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1386 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1388 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1392 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1393 unsigned long num
, struct objc_method
*method
)
1395 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1396 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1400 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1401 struct objc_object
*object
)
1403 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1405 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1409 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1410 struct objc_super
*super
)
1412 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1414 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1415 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1419 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1420 struct objc_class
*theclass
)
1422 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1424 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1425 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1426 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1427 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1428 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1429 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1431 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1432 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1433 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1434 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1438 find_implementation_from_class (struct gdbarch
*gdbarch
,
1439 CORE_ADDR theclass
, CORE_ADDR sel
)
1441 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1442 CORE_ADDR subclass
= theclass
;
1444 while (subclass
!= 0)
1447 struct objc_class class_str
;
1448 unsigned mlistnum
= 0;
1450 read_objc_class (gdbarch
, subclass
, &class_str
);
1455 unsigned long nmethods
;
1458 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1464 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1466 for (i
= 0; i
< nmethods
; i
++)
1468 struct objc_method meth_str
;
1470 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1472 if (meth_str
.name
== sel
)
1473 /* FIXME: hppa arch was doing a pointer dereference
1474 here. There needs to be a better way to do that. */
1475 return meth_str
.imp
;
1479 subclass
= class_str
.super_class
;
1486 find_implementation (struct gdbarch
*gdbarch
,
1487 CORE_ADDR object
, CORE_ADDR sel
)
1489 struct objc_object ostr
;
1493 read_objc_object (gdbarch
, object
, &ostr
);
1497 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1501 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1503 struct frame_info
*frame
= get_current_frame ();
1504 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1505 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1511 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1512 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1514 res
= find_implementation (gdbarch
, object
, sel
);
1523 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1525 struct frame_info
*frame
= get_current_frame ();
1526 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1527 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1533 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1534 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1536 res
= find_implementation (gdbarch
, object
, sel
);
1545 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1547 struct frame_info
*frame
= get_current_frame ();
1548 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1549 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1551 struct objc_super sstr
;
1557 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1558 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1560 read_objc_super (gdbarch
, super
, &sstr
);
1561 if (sstr
.theclass
== 0)
1564 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1573 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1575 struct frame_info
*frame
= get_current_frame ();
1576 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1577 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1579 struct objc_super sstr
;
1585 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1586 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1588 read_objc_super (gdbarch
, super
, &sstr
);
1589 if (sstr
.theclass
== 0)
1592 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);