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 /* la_sniff_from_mangled_name for ObjC. */
287 objc_sniff_from_mangled_name (const char *mangled
, char **demangled
)
289 *demangled
= objc_demangle (mangled
, 0);
290 return *demangled
!= NULL
;
293 /* Determine if we are currently in the Objective-C dispatch function.
294 If so, get the address of the method function that the dispatcher
295 would call and use that as the function to step into instead. Also
296 skip over the trampoline for the function (if any). This is better
297 for the user since they are only interested in stepping into the
298 method function anyway. */
300 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
302 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
303 CORE_ADDR real_stop_pc
;
304 CORE_ADDR method_stop_pc
;
306 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
308 if (real_stop_pc
!= 0)
309 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
311 find_objc_msgcall (stop_pc
, &method_stop_pc
);
315 real_stop_pc
= gdbarch_skip_trampoline_code
316 (gdbarch
, frame
, method_stop_pc
);
317 if (real_stop_pc
== 0)
318 real_stop_pc
= method_stop_pc
;
325 /* Table mapping opcodes into strings for printing operators
326 and precedences of the operators. */
328 static const struct op_print objc_op_print_tab
[] =
330 {",", BINOP_COMMA
, PREC_COMMA
, 0},
331 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
332 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
333 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
334 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
335 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
336 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
337 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
338 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
339 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
340 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
341 {">", BINOP_GTR
, PREC_ORDER
, 0},
342 {"<", BINOP_LESS
, PREC_ORDER
, 0},
343 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
344 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
345 {"+", BINOP_ADD
, PREC_ADD
, 0},
346 {"-", BINOP_SUB
, PREC_ADD
, 0},
347 {"*", BINOP_MUL
, PREC_MUL
, 0},
348 {"/", BINOP_DIV
, PREC_MUL
, 0},
349 {"%", BINOP_REM
, PREC_MUL
, 0},
350 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
351 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
352 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
353 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
354 {"*", UNOP_IND
, PREC_PREFIX
, 0},
355 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
356 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
357 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
358 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
359 {NULL
, OP_NULL
, PREC_NULL
, 0}
362 static const char *objc_extensions
[] =
367 /* Constant data representing the Objective-C language. */
369 extern const struct language_data objc_language_data
=
371 "objective-c", /* Language name */
379 &exp_descriptor_standard
,
382 c_printchar
, /* Print a character constant */
383 c_printstr
, /* Function to print string constant */
385 c_print_type
, /* Print a type using appropriate syntax */
386 c_print_typedef
, /* Print a typedef using appropriate syntax */
387 c_value_print_inner
, /* la_value_print_inner */
388 c_value_print
, /* Print a top-level value */
389 objc_skip_trampoline
, /* Language specific skip_trampoline */
390 "self", /* name_of_this */
391 false, /* la_store_sym_names_in_linkage_form_p */
392 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
393 objc_demangle
, /* Language specific symbol demangler */
394 objc_sniff_from_mangled_name
,
395 NULL
, /* Language specific
396 class_name_from_physname */
397 objc_op_print_tab
, /* Expression operators for printing */
398 1, /* C-style arrays */
399 0, /* String lower bound */
400 default_word_break_characters
,
401 default_collect_symbol_completion_matches
,
402 c_watch_location_expression
,
403 NULL
, /* la_get_symbol_name_matcher */
407 "{...}" /* la_struct_too_deep_ellipsis */
410 /* Class representing the Objective-C language. */
412 class objc_language
: public language_defn
416 : language_defn (language_objc
, objc_language_data
)
419 /* See language.h. */
420 void language_arch_info (struct gdbarch
*gdbarch
,
421 struct language_arch_info
*lai
) const override
423 c_language_arch_info (gdbarch
, lai
);
427 /* Single instance of the class representing the Objective-C language. */
429 static objc_language objc_language_defn
;
433 * Following functions help construct Objective-C message calls.
436 struct selname
/* For parsing Objective-C. */
438 struct selname
*next
;
443 static int msglist_len
;
444 static struct selname
*selname_chain
;
445 static char *msglist_sel
;
450 struct selname
*newobj
= XNEW (struct selname
);
452 newobj
->next
= selname_chain
;
453 newobj
->msglist_len
= msglist_len
;
454 newobj
->msglist_sel
= msglist_sel
;
456 msglist_sel
= (char *)xmalloc(1);
458 selname_chain
= newobj
;
462 add_msglist(struct stoken
*str
, int addcolon
)
468 if (str
== 0) /* Unnamed arg, or... */
470 if (addcolon
== 0) /* variable number of args. */
483 len
= plen
+ strlen(msglist_sel
) + 2;
484 s
= (char *)xmalloc(len
);
485 strcpy(s
, msglist_sel
);
500 end_msglist (struct parser_state
*ps
)
502 int val
= msglist_len
;
503 struct selname
*sel
= selname_chain
;
504 char *p
= msglist_sel
;
507 selname_chain
= sel
->next
;
508 msglist_len
= sel
->msglist_len
;
509 msglist_sel
= sel
->msglist_sel
;
510 selid
= lookup_child_selector (ps
->gdbarch (), p
);
512 error (_("Can't find selector \"%s\""), p
);
513 write_exp_elt_longcst (ps
, selid
);
515 write_exp_elt_longcst (ps
, val
); /* Number of args */
522 * Function: specialcmp (const char *a, const char *b)
524 * Special strcmp: treats ']' and ' ' as end-of-string.
525 * Used for qsorting lists of objc methods (either by class or selector).
529 specialcmp (const char *a
, const char *b
)
531 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
537 if (*a
&& *a
!= ' ' && *a
!= ']')
538 return 1; /* a is longer therefore greater. */
539 if (*b
&& *b
!= ' ' && *b
!= ']')
540 return -1; /* a is shorter therefore lesser. */
541 return 0; /* a and b are identical. */
545 * Function: compare_selectors (const void *, const void *)
547 * Comparison function for use with qsort. Arguments are symbols or
548 * msymbols Compares selector part of objc method name alphabetically.
552 compare_selectors (const void *a
, const void *b
)
554 const char *aname
, *bname
;
556 aname
= (*(struct symbol
**) a
)->print_name ();
557 bname
= (*(struct symbol
**) b
)->print_name ();
558 if (aname
== NULL
|| bname
== NULL
)
559 error (_("internal: compare_selectors(1)"));
561 aname
= strchr(aname
, ' ');
562 bname
= strchr(bname
, ' ');
563 if (aname
== NULL
|| bname
== NULL
)
564 error (_("internal: compare_selectors(2)"));
566 return specialcmp (aname
+1, bname
+1);
570 * Function: selectors_info (regexp, from_tty)
572 * Implements the "Info selectors" command. Takes an optional regexp
573 * arg. Lists all objective c selectors that match the regexp. Works
574 * by grepping thru all symbols for objective c methods. Output list
575 * is sorted and uniqued.
579 info_selectors_command (const char *regexp
, int from_tty
)
588 struct symbol
**sym_arr
;
592 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
595 if (*regexp
== '+' || *regexp
== '-')
596 { /* User wants only class methods or only instance methods. */
597 plusminus
= *regexp
++;
598 while (*regexp
== ' ' || *regexp
== '\t')
602 strcpy(myregexp
, ".*]");
605 /* Allow a few extra bytes because of the strcat below. */
606 if (sizeof (myregexp
) < strlen (regexp
) + 4)
607 error (_("Regexp is too long: %s"), regexp
);
608 strcpy(myregexp
, regexp
);
609 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
610 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
612 strcat(myregexp
, ".*]");
618 val
= re_comp (myregexp
);
620 error (_("Invalid regexp (%s): %s"), val
, regexp
);
623 /* First time thru is JUST to get max length and count. */
624 for (objfile
*objfile
: current_program_space
->objfiles ())
626 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
629 name
= msymbol
->natural_name ();
631 && (name
[0] == '-' || name
[0] == '+')
632 && name
[1] == '[') /* Got a method name. */
634 /* Filter for class/instance methods. */
635 if (plusminus
&& name
[0] != plusminus
)
637 /* Find selector part. */
638 name
= (char *) strchr (name
+2, ' ');
641 complaint (_("Bad method name '%s'"),
642 msymbol
->natural_name ());
645 if (regexp
== NULL
|| re_exec(++name
) != 0)
647 const char *mystart
= name
;
648 const char *myend
= strchr (mystart
, ']');
650 if (myend
&& (myend
- mystart
> maxlen
))
651 maxlen
= myend
- mystart
; /* Get longest selector. */
659 printf_filtered (_("Selectors matching \"%s\":\n\n"),
660 regexp
? regexp
: "*");
662 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
664 for (objfile
*objfile
: current_program_space
->objfiles ())
666 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
669 name
= msymbol
->natural_name ();
671 (name
[0] == '-' || name
[0] == '+') &&
672 name
[1] == '[') /* Got a method name. */
674 /* Filter for class/instance methods. */
675 if (plusminus
&& name
[0] != plusminus
)
677 /* Find selector part. */
678 name
= (char *) strchr(name
+2, ' ');
679 if (regexp
== NULL
|| re_exec(++name
) != 0)
680 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
685 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
687 /* Prevent compare on first iteration. */
689 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
694 name
= sym_arr
[ix
]->natural_name ();
695 name
= strchr (name
, ' ') + 1;
696 if (p
[0] && specialcmp(name
, p
) == 0)
697 continue; /* Seen this one already (not unique). */
699 /* Copy selector part. */
700 while (*name
&& *name
!= ']')
703 /* Print in columns. */
704 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
709 printf_filtered (_("No selectors matching \"%s\"\n"),
710 regexp
? regexp
: "*");
714 * Function: compare_classes (const void *, const void *)
716 * Comparison function for use with qsort. Arguments are symbols or
717 * msymbols Compares class part of objc method name alphabetically.
721 compare_classes (const void *a
, const void *b
)
723 const char *aname
, *bname
;
725 aname
= (*(struct symbol
**) a
)->print_name ();
726 bname
= (*(struct symbol
**) b
)->print_name ();
727 if (aname
== NULL
|| bname
== NULL
)
728 error (_("internal: compare_classes(1)"));
730 return specialcmp (aname
+1, bname
+1);
734 * Function: classes_info(regexp, from_tty)
736 * Implements the "info classes" command for objective c classes.
737 * Lists all objective c classes that match the optional regexp.
738 * Works by grepping thru the list of objective c methods. List will
739 * be sorted and uniqued (since one class may have many methods).
740 * BUGS: will not list a class that has no methods.
744 info_classes_command (const char *regexp
, int from_tty
)
753 struct symbol
**sym_arr
;
756 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
759 /* Allow a few extra bytes because of the strcat below. */
760 if (sizeof (myregexp
) < strlen (regexp
) + 4)
761 error (_("Regexp is too long: %s"), regexp
);
762 strcpy(myregexp
, regexp
);
763 if (myregexp
[strlen(myregexp
) - 1] == '$')
764 /* In the method name, the end of the class name is marked by ' '. */
765 myregexp
[strlen(myregexp
) - 1] = ' ';
767 strcat(myregexp
, ".* ");
772 val
= re_comp (myregexp
);
774 error (_("Invalid regexp (%s): %s"), val
, regexp
);
777 /* First time thru is JUST to get max length and count. */
778 for (objfile
*objfile
: current_program_space
->objfiles ())
780 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
783 name
= msymbol
->natural_name ();
785 (name
[0] == '-' || name
[0] == '+') &&
786 name
[1] == '[') /* Got a method name. */
787 if (regexp
== NULL
|| re_exec(name
+2) != 0)
789 /* Compute length of classname part. */
790 const char *mystart
= name
+ 2;
791 const char *myend
= strchr (mystart
, ' ');
793 if (myend
&& (myend
- mystart
> maxlen
))
794 maxlen
= myend
- mystart
;
801 printf_filtered (_("Classes matching \"%s\":\n\n"),
802 regexp
? regexp
: "*");
803 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
805 for (objfile
*objfile
: current_program_space
->objfiles ())
807 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
810 name
= msymbol
->natural_name ();
812 (name
[0] == '-' || name
[0] == '+') &&
813 name
[1] == '[') /* Got a method name. */
814 if (regexp
== NULL
|| re_exec(name
+2) != 0)
815 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
819 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
821 /* Prevent compare on first iteration. */
823 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
828 name
= sym_arr
[ix
]->natural_name ();
830 if (p
[0] && specialcmp(name
, p
) == 0)
831 continue; /* Seen this one already (not unique). */
833 /* Copy class part of method name. */
834 while (*name
&& *name
!= ' ')
837 /* Print in columns. */
838 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
843 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
847 parse_selector (char *method
, char **selector
)
853 char *nselector
= NULL
;
855 gdb_assert (selector
!= NULL
);
859 s1
= skip_spaces (s1
);
865 s1
= skip_spaces (s1
);
872 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
874 else if (isspace (*s2
))
876 else if ((*s2
== '\0') || (*s2
== '\''))
884 s2
= skip_spaces (s2
);
889 s2
= skip_spaces (s2
);
892 if (selector
!= NULL
)
893 *selector
= nselector
;
899 parse_method (char *method
, char *type
, char **theclass
,
900 char **category
, char **selector
)
908 char *ncategory
= NULL
;
909 char *nselector
= NULL
;
911 gdb_assert (type
!= NULL
);
912 gdb_assert (theclass
!= NULL
);
913 gdb_assert (category
!= NULL
);
914 gdb_assert (selector
!= NULL
);
918 s1
= skip_spaces (s1
);
924 s1
= skip_spaces (s1
);
926 if ((s1
[0] == '+') || (s1
[0] == '-'))
929 s1
= skip_spaces (s1
);
936 while (isalnum (*s1
) || (*s1
== '_'))
940 s2
= skip_spaces (s2
);
945 s2
= skip_spaces (s2
);
947 while (isalnum (*s2
) || (*s2
== '_'))
952 /* Truncate the class name now that we're not using the open paren. */
960 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
962 else if (isspace (*s2
))
973 s2
= skip_spaces (s2
);
979 s2
= skip_spaces (s2
);
984 if (theclass
!= NULL
)
986 if (category
!= NULL
)
987 *category
= ncategory
;
988 if (selector
!= NULL
)
989 *selector
= nselector
;
995 find_methods (char type
, const char *theclass
, const char *category
,
996 const char *selector
,
997 std::vector
<const char *> *symbol_names
)
999 const char *symname
= NULL
;
1002 char *nclass
= NULL
;
1003 char *ncategory
= NULL
;
1004 char *nselector
= NULL
;
1006 static char *tmp
= NULL
;
1007 static unsigned int tmplen
= 0;
1009 gdb_assert (symbol_names
!= NULL
);
1011 for (objfile
*objfile
: current_program_space
->objfiles ())
1013 unsigned int *objc_csym
;
1015 /* The objfile_csym variable counts the number of ObjC methods
1016 that this objfile defines. We save that count as a private
1017 objfile data. If we have already determined that this objfile
1018 provides no ObjC methods, we can skip it entirely. */
1020 unsigned int objfile_csym
= 0;
1022 objc_csym
= objc_objfile_data
.get (objfile
);
1023 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1024 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1027 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1031 /* Check the symbol name first as this can be done entirely without
1032 sending any query to the target. */
1033 symname
= msymbol
->natural_name ();
1034 if (symname
== NULL
)
1037 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1038 /* Not a method name. */
1043 /* Now that thinks are a bit sane, clean up the symname. */
1044 while ((strlen (symname
) + 1) >= tmplen
)
1046 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1047 tmp
= (char *) xrealloc (tmp
, tmplen
);
1049 strcpy (tmp
, symname
);
1051 if (parse_method (tmp
, &ntype
, &nclass
,
1052 &ncategory
, &nselector
) == NULL
)
1055 if ((type
!= '\0') && (ntype
!= type
))
1058 if ((theclass
!= NULL
)
1059 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1062 if ((category
!= NULL
) &&
1063 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1066 if ((selector
!= NULL
) &&
1067 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1070 symbol_names
->push_back (symname
);
1073 if (objc_csym
== NULL
)
1074 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1076 /* Count of ObjC methods in this objfile should be constant. */
1077 gdb_assert (*objc_csym
== objfile_csym
);
1081 /* Uniquify a vector of strings. */
1084 uniquify_strings (std::vector
<const char *> *strings
)
1086 if (strings
->empty ())
1089 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1090 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1095 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1097 * Input: a string representing a selector
1098 * a pointer to an array of symbol pointers
1099 * possibly a pointer to a symbol found by the caller.
1101 * Output: number of methods that implement that selector. Side
1102 * effects: The array of symbol pointers is filled with matching syms.
1104 * By analogy with function "find_methods" (symtab.c), builds a list
1105 * of symbols matching the ambiguous input, so that "decode_line_2"
1106 * (symtab.c) can list them and ask the user to choose one or more.
1107 * In this case the matches are objective c methods
1108 * ("implementations") matching an objective c selector.
1110 * Note that it is possible for a normal (c-style) function to have
1111 * the same name as an objective c selector. To prevent the selector
1112 * from eclipsing the function, we allow the caller (decode_line_1) to
1113 * search for such a function first, and if it finds one, pass it in
1114 * to us. We will then integrate it into the list. We also search
1115 * for one here, among the minsyms.
1117 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1118 * into two parts: debuggable (struct symbol) syms, and
1119 * non_debuggable (struct minimal_symbol) syms. The debuggable
1120 * ones will come first, before NUM_DEBUGGABLE (which will thus
1121 * be the index of the first non-debuggable one).
1125 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1128 char *theclass
= NULL
;
1129 char *category
= NULL
;
1130 char *selector
= NULL
;
1135 int selector_case
= 0;
1137 gdb_assert (symbol_names
!= NULL
);
1139 buf
= (char *) alloca (strlen (method
) + 1);
1140 strcpy (buf
, method
);
1141 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1145 strcpy (buf
, method
);
1146 tmp
= parse_selector (buf
, &selector
);
1154 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1156 /* If we hit the "selector" case, and we found some methods, then
1157 add the selector itself as a symbol, if it exists. */
1158 if (selector_case
&& !symbol_names
->empty ())
1160 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1164 symbol_names
->push_back (sym
->natural_name ());
1167 struct bound_minimal_symbol msym
1168 = lookup_minimal_symbol (selector
, 0, 0);
1170 if (msym
.minsym
!= NULL
)
1171 symbol_names
->push_back (msym
.minsym
->natural_name ());
1175 uniquify_strings (symbol_names
);
1177 return method
+ (tmp
- buf
);
1181 print_object_command (const char *args
, int from_tty
)
1183 struct value
*object
, *function
, *description
;
1184 CORE_ADDR string_addr
, object_addr
;
1188 if (!args
|| !*args
)
1190 "The 'print-object' command requires an argument (an Objective-C object)");
1193 expression_up expr
= parse_expression (args
);
1196 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1197 expr
.get (), &pc
, EVAL_NORMAL
);
1200 /* Validate the address for sanity. */
1201 object_addr
= value_as_long (object
);
1202 read_memory (object_addr
, &c
, 1);
1204 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1205 if (function
== NULL
)
1206 error (_("Unable to locate _NSPrintForDebugger in child process"));
1208 description
= call_function_by_hand (function
, NULL
, object
);
1210 string_addr
= value_as_long (description
);
1211 if (string_addr
== 0)
1212 error (_("object returns null description"));
1214 read_memory (string_addr
+ i
++, &c
, 1);
1217 { /* Read and print characters up to EOS. */
1219 printf_filtered ("%c", c
);
1220 read_memory (string_addr
+ i
++, &c
, 1);
1223 printf_filtered(_("<object returns empty description>"));
1224 printf_filtered ("\n");
1227 /* The data structure 'methcalls' is used to detect method calls (thru
1228 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1229 * and ultimately find the method being called.
1232 struct objc_methcall
{
1234 /* Return instance method to be called. */
1235 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1236 /* Start of pc range corresponding to method invocation. */
1238 /* End of pc range corresponding to method invocation. */
1242 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1243 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1244 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1245 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1247 static struct objc_methcall methcalls
[] = {
1248 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1249 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1250 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1251 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1252 { "_objc_getClass", NULL
, 0, 0},
1253 { "_objc_getMetaClass", NULL
, 0, 0}
1256 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1258 /* The following function, "find_objc_msgsend", fills in the data
1259 * structure "objc_msgs" by finding the addresses of each of the
1260 * (currently four) functions that it holds (of which objc_msgSend is
1261 * the first). This must be called each time symbols are loaded, in
1262 * case the functions have moved for some reason.
1266 find_objc_msgsend (void)
1270 for (i
= 0; i
< nmethcalls
; i
++)
1272 struct bound_minimal_symbol func
;
1274 /* Try both with and without underscore. */
1275 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1276 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1278 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1280 if (func
.minsym
== NULL
)
1282 methcalls
[i
].begin
= 0;
1283 methcalls
[i
].end
= 0;
1287 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1288 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1292 /* find_objc_msgcall (replaces pc_off_limits)
1294 * ALL that this function now does is to determine whether the input
1295 * address ("pc") is the address of one of the Objective-C message
1296 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1297 * if so, it returns the address of the method that will be called.
1299 * The old function "pc_off_limits" used to do a lot of other things
1300 * in addition, such as detecting shared library jump stubs and
1301 * returning the address of the shlib function that would be called.
1302 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1303 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1304 * dependent modules.
1308 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1314 if (f (pc
, new_pc
) == 0)
1317 catch (const gdb_exception
&ex
)
1319 exception_fprintf (gdb_stderr
, ex
,
1320 "Unable to determine target of "
1321 "Objective-C method call (ignoring):\n");
1328 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1332 find_objc_msgsend ();
1338 for (i
= 0; i
< nmethcalls
; i
++)
1339 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1341 if (methcalls
[i
].stop_at
!= NULL
)
1342 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1351 void _initialize_objc_language ();
1353 _initialize_objc_language ()
1355 add_info ("selectors", info_selectors_command
,
1356 _("All Objective-C selectors, or those matching REGEXP."));
1357 add_info ("classes", info_classes_command
,
1358 _("All Objective-C classes, or those matching REGEXP."));
1359 add_com ("print-object", class_vars
, print_object_command
,
1360 _("Ask an Objective-C object to print itself."));
1361 add_com_alias ("po", "print-object", class_vars
, 1);
1365 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1366 struct objc_method
*method
)
1368 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1370 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1371 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1372 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1375 static unsigned long
1376 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1378 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1380 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1384 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1385 unsigned long num
, struct objc_method
*method
)
1387 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1388 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1392 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1393 struct objc_object
*object
)
1395 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1397 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1401 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1402 struct objc_super
*super
)
1404 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1406 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1407 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1411 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1412 struct objc_class
*theclass
)
1414 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1416 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1417 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1418 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1419 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1420 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1421 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1423 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1424 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1425 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1426 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1430 find_implementation_from_class (struct gdbarch
*gdbarch
,
1431 CORE_ADDR theclass
, CORE_ADDR sel
)
1433 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1434 CORE_ADDR subclass
= theclass
;
1436 while (subclass
!= 0)
1439 struct objc_class class_str
;
1440 unsigned mlistnum
= 0;
1442 read_objc_class (gdbarch
, subclass
, &class_str
);
1447 unsigned long nmethods
;
1450 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1456 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1458 for (i
= 0; i
< nmethods
; i
++)
1460 struct objc_method meth_str
;
1462 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1464 if (meth_str
.name
== sel
)
1465 /* FIXME: hppa arch was doing a pointer dereference
1466 here. There needs to be a better way to do that. */
1467 return meth_str
.imp
;
1471 subclass
= class_str
.super_class
;
1478 find_implementation (struct gdbarch
*gdbarch
,
1479 CORE_ADDR object
, CORE_ADDR sel
)
1481 struct objc_object ostr
;
1485 read_objc_object (gdbarch
, object
, &ostr
);
1489 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1493 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1495 struct frame_info
*frame
= get_current_frame ();
1496 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1497 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1503 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1504 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1506 res
= find_implementation (gdbarch
, object
, sel
);
1515 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1517 struct frame_info
*frame
= get_current_frame ();
1518 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1519 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1525 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1526 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1528 res
= find_implementation (gdbarch
, object
, sel
);
1537 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1539 struct frame_info
*frame
= get_current_frame ();
1540 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1541 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1543 struct objc_super sstr
;
1549 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1550 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1552 read_objc_super (gdbarch
, super
, &sstr
);
1553 if (sstr
.theclass
== 0)
1556 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1565 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1567 struct frame_info
*frame
= get_current_frame ();
1568 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1569 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1571 struct objc_super sstr
;
1577 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1578 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1580 read_objc_super (gdbarch
, super
, &sstr
);
1581 if (sstr
.theclass
== 0)
1584 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);