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 * const 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
,
340 "self", /* name_of_this */
341 false, /* la_store_sym_names_in_linkage_form_p */
342 objc_op_print_tab
, /* Expression operators for printing */
343 1, /* C-style arrays */
344 0, /* String lower bound */
348 /* Class representing the Objective-C language. */
350 class objc_language
: public language_defn
354 : language_defn (language_objc
, objc_language_data
)
357 /* See language.h. */
358 void language_arch_info (struct gdbarch
*gdbarch
,
359 struct language_arch_info
*lai
) const override
361 c_language_arch_info (gdbarch
, lai
);
364 /* See language.h. */
365 bool sniff_from_mangled_name (const char *mangled
,
366 char **demangled
) const override
368 *demangled
= objc_demangle (mangled
, 0);
369 return *demangled
!= NULL
;
372 /* See language.h. */
374 char *demangle (const char *mangled
, int options
) const override
376 return objc_demangle (mangled
, options
);
379 /* See language.h. */
381 void print_type (struct type
*type
, const char *varstring
,
382 struct ui_file
*stream
, int show
, int level
,
383 const struct type_print_options
*flags
) const override
385 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
388 /* See language.h. */
390 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
391 CORE_ADDR stop_pc
) const override
393 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
394 CORE_ADDR real_stop_pc
;
395 CORE_ADDR method_stop_pc
;
397 /* Determine if we are currently in the Objective-C dispatch function.
398 If so, get the address of the method function that the dispatcher
399 would call and use that as the function to step into instead. Also
400 skip over the trampoline for the function (if any). This is better
401 for the user since they are only interested in stepping into the
402 method function anyway. */
404 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
406 if (real_stop_pc
!= 0)
407 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
409 find_objc_msgcall (stop_pc
, &method_stop_pc
);
413 real_stop_pc
= gdbarch_skip_trampoline_code
414 (gdbarch
, frame
, method_stop_pc
);
415 if (real_stop_pc
== 0)
416 real_stop_pc
= method_stop_pc
;
423 /* Single instance of the class representing the Objective-C language. */
425 static objc_language objc_language_defn
;
429 * Following functions help construct Objective-C message calls.
432 struct selname
/* For parsing Objective-C. */
434 struct selname
*next
;
439 static int msglist_len
;
440 static struct selname
*selname_chain
;
441 static char *msglist_sel
;
446 struct selname
*newobj
= XNEW (struct selname
);
448 newobj
->next
= selname_chain
;
449 newobj
->msglist_len
= msglist_len
;
450 newobj
->msglist_sel
= msglist_sel
;
452 msglist_sel
= (char *)xmalloc(1);
454 selname_chain
= newobj
;
458 add_msglist(struct stoken
*str
, int addcolon
)
464 if (str
== 0) /* Unnamed arg, or... */
466 if (addcolon
== 0) /* variable number of args. */
479 len
= plen
+ strlen(msglist_sel
) + 2;
480 s
= (char *)xmalloc(len
);
481 strcpy(s
, msglist_sel
);
496 end_msglist (struct parser_state
*ps
)
498 int val
= msglist_len
;
499 struct selname
*sel
= selname_chain
;
500 char *p
= msglist_sel
;
503 selname_chain
= sel
->next
;
504 msglist_len
= sel
->msglist_len
;
505 msglist_sel
= sel
->msglist_sel
;
506 selid
= lookup_child_selector (ps
->gdbarch (), p
);
508 error (_("Can't find selector \"%s\""), p
);
509 write_exp_elt_longcst (ps
, selid
);
511 write_exp_elt_longcst (ps
, val
); /* Number of args */
518 * Function: specialcmp (const char *a, const char *b)
520 * Special strcmp: treats ']' and ' ' as end-of-string.
521 * Used for qsorting lists of objc methods (either by class or selector).
525 specialcmp (const char *a
, const char *b
)
527 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
533 if (*a
&& *a
!= ' ' && *a
!= ']')
534 return 1; /* a is longer therefore greater. */
535 if (*b
&& *b
!= ' ' && *b
!= ']')
536 return -1; /* a is shorter therefore lesser. */
537 return 0; /* a and b are identical. */
541 * Function: compare_selectors (const void *, const void *)
543 * Comparison function for use with qsort. Arguments are symbols or
544 * msymbols Compares selector part of objc method name alphabetically.
548 compare_selectors (const void *a
, const void *b
)
550 const char *aname
, *bname
;
552 aname
= (*(struct symbol
**) a
)->print_name ();
553 bname
= (*(struct symbol
**) b
)->print_name ();
554 if (aname
== NULL
|| bname
== NULL
)
555 error (_("internal: compare_selectors(1)"));
557 aname
= strchr(aname
, ' ');
558 bname
= strchr(bname
, ' ');
559 if (aname
== NULL
|| bname
== NULL
)
560 error (_("internal: compare_selectors(2)"));
562 return specialcmp (aname
+1, bname
+1);
566 * Function: selectors_info (regexp, from_tty)
568 * Implements the "Info selectors" command. Takes an optional regexp
569 * arg. Lists all objective c selectors that match the regexp. Works
570 * by grepping thru all symbols for objective c methods. Output list
571 * is sorted and uniqued.
575 info_selectors_command (const char *regexp
, int from_tty
)
584 struct symbol
**sym_arr
;
588 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
591 if (*regexp
== '+' || *regexp
== '-')
592 { /* User wants only class methods or only instance methods. */
593 plusminus
= *regexp
++;
594 while (*regexp
== ' ' || *regexp
== '\t')
598 strcpy(myregexp
, ".*]");
601 /* Allow a few extra bytes because of the strcat below. */
602 if (sizeof (myregexp
) < strlen (regexp
) + 4)
603 error (_("Regexp is too long: %s"), regexp
);
604 strcpy(myregexp
, regexp
);
605 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
606 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
608 strcat(myregexp
, ".*]");
614 val
= re_comp (myregexp
);
616 error (_("Invalid regexp (%s): %s"), val
, regexp
);
619 /* First time thru is JUST to get max length and count. */
620 for (objfile
*objfile
: current_program_space
->objfiles ())
622 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
625 name
= msymbol
->natural_name ();
627 && (name
[0] == '-' || name
[0] == '+')
628 && name
[1] == '[') /* Got a method name. */
630 /* Filter for class/instance methods. */
631 if (plusminus
&& name
[0] != plusminus
)
633 /* Find selector part. */
634 name
= (char *) strchr (name
+2, ' ');
637 complaint (_("Bad method name '%s'"),
638 msymbol
->natural_name ());
641 if (regexp
== NULL
|| re_exec(++name
) != 0)
643 const char *mystart
= name
;
644 const char *myend
= strchr (mystart
, ']');
646 if (myend
&& (myend
- mystart
> maxlen
))
647 maxlen
= myend
- mystart
; /* Get longest selector. */
655 printf_filtered (_("Selectors matching \"%s\":\n\n"),
656 regexp
? regexp
: "*");
658 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
660 for (objfile
*objfile
: current_program_space
->objfiles ())
662 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
665 name
= msymbol
->natural_name ();
667 (name
[0] == '-' || name
[0] == '+') &&
668 name
[1] == '[') /* Got a method name. */
670 /* Filter for class/instance methods. */
671 if (plusminus
&& name
[0] != plusminus
)
673 /* Find selector part. */
674 name
= (char *) strchr(name
+2, ' ');
675 if (regexp
== NULL
|| re_exec(++name
) != 0)
676 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
681 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
683 /* Prevent compare on first iteration. */
685 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
690 name
= sym_arr
[ix
]->natural_name ();
691 name
= strchr (name
, ' ') + 1;
692 if (p
[0] && specialcmp(name
, p
) == 0)
693 continue; /* Seen this one already (not unique). */
695 /* Copy selector part. */
696 while (*name
&& *name
!= ']')
699 /* Print in columns. */
700 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
705 printf_filtered (_("No selectors matching \"%s\"\n"),
706 regexp
? regexp
: "*");
710 * Function: compare_classes (const void *, const void *)
712 * Comparison function for use with qsort. Arguments are symbols or
713 * msymbols Compares class part of objc method name alphabetically.
717 compare_classes (const void *a
, const void *b
)
719 const char *aname
, *bname
;
721 aname
= (*(struct symbol
**) a
)->print_name ();
722 bname
= (*(struct symbol
**) b
)->print_name ();
723 if (aname
== NULL
|| bname
== NULL
)
724 error (_("internal: compare_classes(1)"));
726 return specialcmp (aname
+1, bname
+1);
730 * Function: classes_info(regexp, from_tty)
732 * Implements the "info classes" command for objective c classes.
733 * Lists all objective c classes that match the optional regexp.
734 * Works by grepping thru the list of objective c methods. List will
735 * be sorted and uniqued (since one class may have many methods).
736 * BUGS: will not list a class that has no methods.
740 info_classes_command (const char *regexp
, int from_tty
)
749 struct symbol
**sym_arr
;
752 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
755 /* Allow a few extra bytes because of the strcat below. */
756 if (sizeof (myregexp
) < strlen (regexp
) + 4)
757 error (_("Regexp is too long: %s"), regexp
);
758 strcpy(myregexp
, regexp
);
759 if (myregexp
[strlen(myregexp
) - 1] == '$')
760 /* In the method name, the end of the class name is marked by ' '. */
761 myregexp
[strlen(myregexp
) - 1] = ' ';
763 strcat(myregexp
, ".* ");
768 val
= re_comp (myregexp
);
770 error (_("Invalid regexp (%s): %s"), val
, regexp
);
773 /* First time thru is JUST to get max length and count. */
774 for (objfile
*objfile
: current_program_space
->objfiles ())
776 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
779 name
= msymbol
->natural_name ();
781 (name
[0] == '-' || name
[0] == '+') &&
782 name
[1] == '[') /* Got a method name. */
783 if (regexp
== NULL
|| re_exec(name
+2) != 0)
785 /* Compute length of classname part. */
786 const char *mystart
= name
+ 2;
787 const char *myend
= strchr (mystart
, ' ');
789 if (myend
&& (myend
- mystart
> maxlen
))
790 maxlen
= myend
- mystart
;
797 printf_filtered (_("Classes matching \"%s\":\n\n"),
798 regexp
? regexp
: "*");
799 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
801 for (objfile
*objfile
: current_program_space
->objfiles ())
803 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
806 name
= msymbol
->natural_name ();
808 (name
[0] == '-' || name
[0] == '+') &&
809 name
[1] == '[') /* Got a method name. */
810 if (regexp
== NULL
|| re_exec(name
+2) != 0)
811 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
815 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
817 /* Prevent compare on first iteration. */
819 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
824 name
= sym_arr
[ix
]->natural_name ();
826 if (p
[0] && specialcmp(name
, p
) == 0)
827 continue; /* Seen this one already (not unique). */
829 /* Copy class part of method name. */
830 while (*name
&& *name
!= ' ')
833 /* Print in columns. */
834 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
839 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
843 parse_selector (char *method
, char **selector
)
849 char *nselector
= NULL
;
851 gdb_assert (selector
!= NULL
);
855 s1
= skip_spaces (s1
);
861 s1
= skip_spaces (s1
);
868 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
870 else if (isspace (*s2
))
872 else if ((*s2
== '\0') || (*s2
== '\''))
880 s2
= skip_spaces (s2
);
885 s2
= skip_spaces (s2
);
888 if (selector
!= NULL
)
889 *selector
= nselector
;
895 parse_method (char *method
, char *type
, char **theclass
,
896 char **category
, char **selector
)
904 char *ncategory
= NULL
;
905 char *nselector
= NULL
;
907 gdb_assert (type
!= NULL
);
908 gdb_assert (theclass
!= NULL
);
909 gdb_assert (category
!= NULL
);
910 gdb_assert (selector
!= NULL
);
914 s1
= skip_spaces (s1
);
920 s1
= skip_spaces (s1
);
922 if ((s1
[0] == '+') || (s1
[0] == '-'))
925 s1
= skip_spaces (s1
);
932 while (isalnum (*s1
) || (*s1
== '_'))
936 s2
= skip_spaces (s2
);
941 s2
= skip_spaces (s2
);
943 while (isalnum (*s2
) || (*s2
== '_'))
948 /* Truncate the class name now that we're not using the open paren. */
956 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
958 else if (isspace (*s2
))
969 s2
= skip_spaces (s2
);
975 s2
= skip_spaces (s2
);
980 if (theclass
!= NULL
)
982 if (category
!= NULL
)
983 *category
= ncategory
;
984 if (selector
!= NULL
)
985 *selector
= nselector
;
991 find_methods (char type
, const char *theclass
, const char *category
,
992 const char *selector
,
993 std::vector
<const char *> *symbol_names
)
995 const char *symname
= NULL
;
999 char *ncategory
= NULL
;
1000 char *nselector
= NULL
;
1002 static char *tmp
= NULL
;
1003 static unsigned int tmplen
= 0;
1005 gdb_assert (symbol_names
!= NULL
);
1007 for (objfile
*objfile
: current_program_space
->objfiles ())
1009 unsigned int *objc_csym
;
1011 /* The objfile_csym variable counts the number of ObjC methods
1012 that this objfile defines. We save that count as a private
1013 objfile data. If we have already determined that this objfile
1014 provides no ObjC methods, we can skip it entirely. */
1016 unsigned int objfile_csym
= 0;
1018 objc_csym
= objc_objfile_data
.get (objfile
);
1019 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1020 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1023 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1027 /* Check the symbol name first as this can be done entirely without
1028 sending any query to the target. */
1029 symname
= msymbol
->natural_name ();
1030 if (symname
== NULL
)
1033 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1034 /* Not a method name. */
1039 /* Now that thinks are a bit sane, clean up the symname. */
1040 while ((strlen (symname
) + 1) >= tmplen
)
1042 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1043 tmp
= (char *) xrealloc (tmp
, tmplen
);
1045 strcpy (tmp
, symname
);
1047 if (parse_method (tmp
, &ntype
, &nclass
,
1048 &ncategory
, &nselector
) == NULL
)
1051 if ((type
!= '\0') && (ntype
!= type
))
1054 if ((theclass
!= NULL
)
1055 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1058 if ((category
!= NULL
) &&
1059 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1062 if ((selector
!= NULL
) &&
1063 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1066 symbol_names
->push_back (symname
);
1069 if (objc_csym
== NULL
)
1070 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1072 /* Count of ObjC methods in this objfile should be constant. */
1073 gdb_assert (*objc_csym
== objfile_csym
);
1077 /* Uniquify a vector of strings. */
1080 uniquify_strings (std::vector
<const char *> *strings
)
1082 if (strings
->empty ())
1085 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1086 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1091 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1093 * Input: a string representing a selector
1094 * a pointer to an array of symbol pointers
1095 * possibly a pointer to a symbol found by the caller.
1097 * Output: number of methods that implement that selector. Side
1098 * effects: The array of symbol pointers is filled with matching syms.
1100 * By analogy with function "find_methods" (symtab.c), builds a list
1101 * of symbols matching the ambiguous input, so that "decode_line_2"
1102 * (symtab.c) can list them and ask the user to choose one or more.
1103 * In this case the matches are objective c methods
1104 * ("implementations") matching an objective c selector.
1106 * Note that it is possible for a normal (c-style) function to have
1107 * the same name as an objective c selector. To prevent the selector
1108 * from eclipsing the function, we allow the caller (decode_line_1) to
1109 * search for such a function first, and if it finds one, pass it in
1110 * to us. We will then integrate it into the list. We also search
1111 * for one here, among the minsyms.
1113 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1114 * into two parts: debuggable (struct symbol) syms, and
1115 * non_debuggable (struct minimal_symbol) syms. The debuggable
1116 * ones will come first, before NUM_DEBUGGABLE (which will thus
1117 * be the index of the first non-debuggable one).
1121 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1124 char *theclass
= NULL
;
1125 char *category
= NULL
;
1126 char *selector
= NULL
;
1131 int selector_case
= 0;
1133 gdb_assert (symbol_names
!= NULL
);
1135 buf
= (char *) alloca (strlen (method
) + 1);
1136 strcpy (buf
, method
);
1137 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1141 strcpy (buf
, method
);
1142 tmp
= parse_selector (buf
, &selector
);
1150 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1152 /* If we hit the "selector" case, and we found some methods, then
1153 add the selector itself as a symbol, if it exists. */
1154 if (selector_case
&& !symbol_names
->empty ())
1156 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1160 symbol_names
->push_back (sym
->natural_name ());
1163 struct bound_minimal_symbol msym
1164 = lookup_minimal_symbol (selector
, 0, 0);
1166 if (msym
.minsym
!= NULL
)
1167 symbol_names
->push_back (msym
.minsym
->natural_name ());
1171 uniquify_strings (symbol_names
);
1173 return method
+ (tmp
- buf
);
1177 print_object_command (const char *args
, int from_tty
)
1179 struct value
*object
, *function
, *description
;
1180 CORE_ADDR string_addr
, object_addr
;
1184 if (!args
|| !*args
)
1186 "The 'print-object' command requires an argument (an Objective-C object)");
1189 expression_up expr
= parse_expression (args
);
1192 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1193 expr
.get (), &pc
, EVAL_NORMAL
);
1196 /* Validate the address for sanity. */
1197 object_addr
= value_as_long (object
);
1198 read_memory (object_addr
, &c
, 1);
1200 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1201 if (function
== NULL
)
1202 error (_("Unable to locate _NSPrintForDebugger in child process"));
1204 description
= call_function_by_hand (function
, NULL
, object
);
1206 string_addr
= value_as_long (description
);
1207 if (string_addr
== 0)
1208 error (_("object returns null description"));
1210 read_memory (string_addr
+ i
++, &c
, 1);
1213 { /* Read and print characters up to EOS. */
1215 printf_filtered ("%c", c
);
1216 read_memory (string_addr
+ i
++, &c
, 1);
1219 printf_filtered(_("<object returns empty description>"));
1220 printf_filtered ("\n");
1223 /* The data structure 'methcalls' is used to detect method calls (thru
1224 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1225 * and ultimately find the method being called.
1228 struct objc_methcall
{
1230 /* Return instance method to be called. */
1231 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1232 /* Start of pc range corresponding to method invocation. */
1234 /* End of pc range corresponding to method invocation. */
1238 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1239 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1240 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1241 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1243 static struct objc_methcall methcalls
[] = {
1244 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1245 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1246 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1247 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1248 { "_objc_getClass", NULL
, 0, 0},
1249 { "_objc_getMetaClass", NULL
, 0, 0}
1252 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1254 /* The following function, "find_objc_msgsend", fills in the data
1255 * structure "objc_msgs" by finding the addresses of each of the
1256 * (currently four) functions that it holds (of which objc_msgSend is
1257 * the first). This must be called each time symbols are loaded, in
1258 * case the functions have moved for some reason.
1262 find_objc_msgsend (void)
1266 for (i
= 0; i
< nmethcalls
; i
++)
1268 struct bound_minimal_symbol func
;
1270 /* Try both with and without underscore. */
1271 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1272 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1274 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1276 if (func
.minsym
== NULL
)
1278 methcalls
[i
].begin
= 0;
1279 methcalls
[i
].end
= 0;
1283 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1284 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1288 /* find_objc_msgcall (replaces pc_off_limits)
1290 * ALL that this function now does is to determine whether the input
1291 * address ("pc") is the address of one of the Objective-C message
1292 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1293 * if so, it returns the address of the method that will be called.
1295 * The old function "pc_off_limits" used to do a lot of other things
1296 * in addition, such as detecting shared library jump stubs and
1297 * returning the address of the shlib function that would be called.
1298 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1299 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1300 * dependent modules.
1304 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1310 if (f (pc
, new_pc
) == 0)
1313 catch (const gdb_exception
&ex
)
1315 exception_fprintf (gdb_stderr
, ex
,
1316 "Unable to determine target of "
1317 "Objective-C method call (ignoring):\n");
1324 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1328 find_objc_msgsend ();
1334 for (i
= 0; i
< nmethcalls
; i
++)
1335 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1337 if (methcalls
[i
].stop_at
!= NULL
)
1338 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1347 void _initialize_objc_language ();
1349 _initialize_objc_language ()
1351 add_info ("selectors", info_selectors_command
,
1352 _("All Objective-C selectors, or those matching REGEXP."));
1353 add_info ("classes", info_classes_command
,
1354 _("All Objective-C classes, or those matching REGEXP."));
1355 add_com ("print-object", class_vars
, print_object_command
,
1356 _("Ask an Objective-C object to print itself."));
1357 add_com_alias ("po", "print-object", class_vars
, 1);
1361 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1362 struct objc_method
*method
)
1364 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1366 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1367 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1368 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1371 static unsigned long
1372 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1374 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1376 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1380 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1381 unsigned long num
, struct objc_method
*method
)
1383 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1384 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1388 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1389 struct objc_object
*object
)
1391 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1393 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1397 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1398 struct objc_super
*super
)
1400 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1402 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1403 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1407 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1408 struct objc_class
*theclass
)
1410 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1412 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1413 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1414 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1415 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1416 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1417 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1419 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1420 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1421 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1422 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1426 find_implementation_from_class (struct gdbarch
*gdbarch
,
1427 CORE_ADDR theclass
, CORE_ADDR sel
)
1429 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1430 CORE_ADDR subclass
= theclass
;
1432 while (subclass
!= 0)
1435 struct objc_class class_str
;
1436 unsigned mlistnum
= 0;
1438 read_objc_class (gdbarch
, subclass
, &class_str
);
1443 unsigned long nmethods
;
1446 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1452 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1454 for (i
= 0; i
< nmethods
; i
++)
1456 struct objc_method meth_str
;
1458 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1460 if (meth_str
.name
== sel
)
1461 /* FIXME: hppa arch was doing a pointer dereference
1462 here. There needs to be a better way to do that. */
1463 return meth_str
.imp
;
1467 subclass
= class_str
.super_class
;
1474 find_implementation (struct gdbarch
*gdbarch
,
1475 CORE_ADDR object
, CORE_ADDR sel
)
1477 struct objc_object ostr
;
1481 read_objc_object (gdbarch
, object
, &ostr
);
1485 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1489 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1491 struct frame_info
*frame
= get_current_frame ();
1492 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1493 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1499 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1500 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1502 res
= find_implementation (gdbarch
, object
, sel
);
1511 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1513 struct frame_info
*frame
= get_current_frame ();
1514 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1515 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1521 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1522 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1524 res
= find_implementation (gdbarch
, object
, sel
);
1533 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1535 struct frame_info
*frame
= get_current_frame ();
1536 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1537 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1539 struct objc_super sstr
;
1545 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1546 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1548 read_objc_super (gdbarch
, super
, &sstr
);
1549 if (sstr
.theclass
== 0)
1552 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1561 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1563 struct frame_info
*frame
= get_current_frame ();
1564 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1565 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1567 struct objc_super sstr
;
1573 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1574 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1576 read_objc_super (gdbarch
, super
, &sstr
);
1577 if (sstr
.theclass
== 0)
1580 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);