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
,
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 */
346 "{...}" /* la_struct_too_deep_ellipsis */
349 /* Class representing the Objective-C language. */
351 class objc_language
: public language_defn
355 : language_defn (language_objc
, objc_language_data
)
358 /* See language.h. */
359 void language_arch_info (struct gdbarch
*gdbarch
,
360 struct language_arch_info
*lai
) const override
362 c_language_arch_info (gdbarch
, lai
);
365 /* See language.h. */
366 bool sniff_from_mangled_name (const char *mangled
,
367 char **demangled
) const override
369 *demangled
= objc_demangle (mangled
, 0);
370 return *demangled
!= NULL
;
373 /* See language.h. */
375 char *demangle (const char *mangled
, int options
) const override
377 return objc_demangle (mangled
, options
);
380 /* See language.h. */
382 void print_type (struct type
*type
, const char *varstring
,
383 struct ui_file
*stream
, int show
, int level
,
384 const struct type_print_options
*flags
) const override
386 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
389 /* See language.h. */
391 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
392 CORE_ADDR stop_pc
) const override
394 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
395 CORE_ADDR real_stop_pc
;
396 CORE_ADDR method_stop_pc
;
398 /* Determine if we are currently in the Objective-C dispatch function.
399 If so, get the address of the method function that the dispatcher
400 would call and use that as the function to step into instead. Also
401 skip over the trampoline for the function (if any). This is better
402 for the user since they are only interested in stepping into the
403 method function anyway. */
405 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
407 if (real_stop_pc
!= 0)
408 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
410 find_objc_msgcall (stop_pc
, &method_stop_pc
);
414 real_stop_pc
= gdbarch_skip_trampoline_code
415 (gdbarch
, frame
, method_stop_pc
);
416 if (real_stop_pc
== 0)
417 real_stop_pc
= method_stop_pc
;
424 /* Single instance of the class representing the Objective-C language. */
426 static objc_language objc_language_defn
;
430 * Following functions help construct Objective-C message calls.
433 struct selname
/* For parsing Objective-C. */
435 struct selname
*next
;
440 static int msglist_len
;
441 static struct selname
*selname_chain
;
442 static char *msglist_sel
;
447 struct selname
*newobj
= XNEW (struct selname
);
449 newobj
->next
= selname_chain
;
450 newobj
->msglist_len
= msglist_len
;
451 newobj
->msglist_sel
= msglist_sel
;
453 msglist_sel
= (char *)xmalloc(1);
455 selname_chain
= newobj
;
459 add_msglist(struct stoken
*str
, int addcolon
)
465 if (str
== 0) /* Unnamed arg, or... */
467 if (addcolon
== 0) /* variable number of args. */
480 len
= plen
+ strlen(msglist_sel
) + 2;
481 s
= (char *)xmalloc(len
);
482 strcpy(s
, msglist_sel
);
497 end_msglist (struct parser_state
*ps
)
499 int val
= msglist_len
;
500 struct selname
*sel
= selname_chain
;
501 char *p
= msglist_sel
;
504 selname_chain
= sel
->next
;
505 msglist_len
= sel
->msglist_len
;
506 msglist_sel
= sel
->msglist_sel
;
507 selid
= lookup_child_selector (ps
->gdbarch (), p
);
509 error (_("Can't find selector \"%s\""), p
);
510 write_exp_elt_longcst (ps
, selid
);
512 write_exp_elt_longcst (ps
, val
); /* Number of args */
519 * Function: specialcmp (const char *a, const char *b)
521 * Special strcmp: treats ']' and ' ' as end-of-string.
522 * Used for qsorting lists of objc methods (either by class or selector).
526 specialcmp (const char *a
, const char *b
)
528 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
534 if (*a
&& *a
!= ' ' && *a
!= ']')
535 return 1; /* a is longer therefore greater. */
536 if (*b
&& *b
!= ' ' && *b
!= ']')
537 return -1; /* a is shorter therefore lesser. */
538 return 0; /* a and b are identical. */
542 * Function: compare_selectors (const void *, const void *)
544 * Comparison function for use with qsort. Arguments are symbols or
545 * msymbols Compares selector part of objc method name alphabetically.
549 compare_selectors (const void *a
, const void *b
)
551 const char *aname
, *bname
;
553 aname
= (*(struct symbol
**) a
)->print_name ();
554 bname
= (*(struct symbol
**) b
)->print_name ();
555 if (aname
== NULL
|| bname
== NULL
)
556 error (_("internal: compare_selectors(1)"));
558 aname
= strchr(aname
, ' ');
559 bname
= strchr(bname
, ' ');
560 if (aname
== NULL
|| bname
== NULL
)
561 error (_("internal: compare_selectors(2)"));
563 return specialcmp (aname
+1, bname
+1);
567 * Function: selectors_info (regexp, from_tty)
569 * Implements the "Info selectors" command. Takes an optional regexp
570 * arg. Lists all objective c selectors that match the regexp. Works
571 * by grepping thru all symbols for objective c methods. Output list
572 * is sorted and uniqued.
576 info_selectors_command (const char *regexp
, int from_tty
)
585 struct symbol
**sym_arr
;
589 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
592 if (*regexp
== '+' || *regexp
== '-')
593 { /* User wants only class methods or only instance methods. */
594 plusminus
= *regexp
++;
595 while (*regexp
== ' ' || *regexp
== '\t')
599 strcpy(myregexp
, ".*]");
602 /* Allow a few extra bytes because of the strcat below. */
603 if (sizeof (myregexp
) < strlen (regexp
) + 4)
604 error (_("Regexp is too long: %s"), regexp
);
605 strcpy(myregexp
, regexp
);
606 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
607 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
609 strcat(myregexp
, ".*]");
615 val
= re_comp (myregexp
);
617 error (_("Invalid regexp (%s): %s"), val
, regexp
);
620 /* First time thru is JUST to get max length and count. */
621 for (objfile
*objfile
: current_program_space
->objfiles ())
623 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
626 name
= msymbol
->natural_name ();
628 && (name
[0] == '-' || name
[0] == '+')
629 && name
[1] == '[') /* Got a method name. */
631 /* Filter for class/instance methods. */
632 if (plusminus
&& name
[0] != plusminus
)
634 /* Find selector part. */
635 name
= (char *) strchr (name
+2, ' ');
638 complaint (_("Bad method name '%s'"),
639 msymbol
->natural_name ());
642 if (regexp
== NULL
|| re_exec(++name
) != 0)
644 const char *mystart
= name
;
645 const char *myend
= strchr (mystart
, ']');
647 if (myend
&& (myend
- mystart
> maxlen
))
648 maxlen
= myend
- mystart
; /* Get longest selector. */
656 printf_filtered (_("Selectors matching \"%s\":\n\n"),
657 regexp
? regexp
: "*");
659 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
661 for (objfile
*objfile
: current_program_space
->objfiles ())
663 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
666 name
= msymbol
->natural_name ();
668 (name
[0] == '-' || name
[0] == '+') &&
669 name
[1] == '[') /* Got a method name. */
671 /* Filter for class/instance methods. */
672 if (plusminus
&& name
[0] != plusminus
)
674 /* Find selector part. */
675 name
= (char *) strchr(name
+2, ' ');
676 if (regexp
== NULL
|| re_exec(++name
) != 0)
677 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
682 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
684 /* Prevent compare on first iteration. */
686 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
691 name
= sym_arr
[ix
]->natural_name ();
692 name
= strchr (name
, ' ') + 1;
693 if (p
[0] && specialcmp(name
, p
) == 0)
694 continue; /* Seen this one already (not unique). */
696 /* Copy selector part. */
697 while (*name
&& *name
!= ']')
700 /* Print in columns. */
701 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
706 printf_filtered (_("No selectors matching \"%s\"\n"),
707 regexp
? regexp
: "*");
711 * Function: compare_classes (const void *, const void *)
713 * Comparison function for use with qsort. Arguments are symbols or
714 * msymbols Compares class part of objc method name alphabetically.
718 compare_classes (const void *a
, const void *b
)
720 const char *aname
, *bname
;
722 aname
= (*(struct symbol
**) a
)->print_name ();
723 bname
= (*(struct symbol
**) b
)->print_name ();
724 if (aname
== NULL
|| bname
== NULL
)
725 error (_("internal: compare_classes(1)"));
727 return specialcmp (aname
+1, bname
+1);
731 * Function: classes_info(regexp, from_tty)
733 * Implements the "info classes" command for objective c classes.
734 * Lists all objective c classes that match the optional regexp.
735 * Works by grepping thru the list of objective c methods. List will
736 * be sorted and uniqued (since one class may have many methods).
737 * BUGS: will not list a class that has no methods.
741 info_classes_command (const char *regexp
, int from_tty
)
750 struct symbol
**sym_arr
;
753 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
756 /* Allow a few extra bytes because of the strcat below. */
757 if (sizeof (myregexp
) < strlen (regexp
) + 4)
758 error (_("Regexp is too long: %s"), regexp
);
759 strcpy(myregexp
, regexp
);
760 if (myregexp
[strlen(myregexp
) - 1] == '$')
761 /* In the method name, the end of the class name is marked by ' '. */
762 myregexp
[strlen(myregexp
) - 1] = ' ';
764 strcat(myregexp
, ".* ");
769 val
= re_comp (myregexp
);
771 error (_("Invalid regexp (%s): %s"), val
, regexp
);
774 /* First time thru is JUST to get max length and count. */
775 for (objfile
*objfile
: current_program_space
->objfiles ())
777 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
780 name
= msymbol
->natural_name ();
782 (name
[0] == '-' || name
[0] == '+') &&
783 name
[1] == '[') /* Got a method name. */
784 if (regexp
== NULL
|| re_exec(name
+2) != 0)
786 /* Compute length of classname part. */
787 const char *mystart
= name
+ 2;
788 const char *myend
= strchr (mystart
, ' ');
790 if (myend
&& (myend
- mystart
> maxlen
))
791 maxlen
= myend
- mystart
;
798 printf_filtered (_("Classes matching \"%s\":\n\n"),
799 regexp
? regexp
: "*");
800 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
802 for (objfile
*objfile
: current_program_space
->objfiles ())
804 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
807 name
= msymbol
->natural_name ();
809 (name
[0] == '-' || name
[0] == '+') &&
810 name
[1] == '[') /* Got a method name. */
811 if (regexp
== NULL
|| re_exec(name
+2) != 0)
812 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
816 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
818 /* Prevent compare on first iteration. */
820 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
825 name
= sym_arr
[ix
]->natural_name ();
827 if (p
[0] && specialcmp(name
, p
) == 0)
828 continue; /* Seen this one already (not unique). */
830 /* Copy class part of method name. */
831 while (*name
&& *name
!= ' ')
834 /* Print in columns. */
835 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
840 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
844 parse_selector (char *method
, char **selector
)
850 char *nselector
= NULL
;
852 gdb_assert (selector
!= NULL
);
856 s1
= skip_spaces (s1
);
862 s1
= skip_spaces (s1
);
869 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
871 else if (isspace (*s2
))
873 else if ((*s2
== '\0') || (*s2
== '\''))
881 s2
= skip_spaces (s2
);
886 s2
= skip_spaces (s2
);
889 if (selector
!= NULL
)
890 *selector
= nselector
;
896 parse_method (char *method
, char *type
, char **theclass
,
897 char **category
, char **selector
)
905 char *ncategory
= NULL
;
906 char *nselector
= NULL
;
908 gdb_assert (type
!= NULL
);
909 gdb_assert (theclass
!= NULL
);
910 gdb_assert (category
!= NULL
);
911 gdb_assert (selector
!= NULL
);
915 s1
= skip_spaces (s1
);
921 s1
= skip_spaces (s1
);
923 if ((s1
[0] == '+') || (s1
[0] == '-'))
926 s1
= skip_spaces (s1
);
933 while (isalnum (*s1
) || (*s1
== '_'))
937 s2
= skip_spaces (s2
);
942 s2
= skip_spaces (s2
);
944 while (isalnum (*s2
) || (*s2
== '_'))
949 /* Truncate the class name now that we're not using the open paren. */
957 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
959 else if (isspace (*s2
))
970 s2
= skip_spaces (s2
);
976 s2
= skip_spaces (s2
);
981 if (theclass
!= NULL
)
983 if (category
!= NULL
)
984 *category
= ncategory
;
985 if (selector
!= NULL
)
986 *selector
= nselector
;
992 find_methods (char type
, const char *theclass
, const char *category
,
993 const char *selector
,
994 std::vector
<const char *> *symbol_names
)
996 const char *symname
= NULL
;
1000 char *ncategory
= NULL
;
1001 char *nselector
= NULL
;
1003 static char *tmp
= NULL
;
1004 static unsigned int tmplen
= 0;
1006 gdb_assert (symbol_names
!= NULL
);
1008 for (objfile
*objfile
: current_program_space
->objfiles ())
1010 unsigned int *objc_csym
;
1012 /* The objfile_csym variable counts the number of ObjC methods
1013 that this objfile defines. We save that count as a private
1014 objfile data. If we have already determined that this objfile
1015 provides no ObjC methods, we can skip it entirely. */
1017 unsigned int objfile_csym
= 0;
1019 objc_csym
= objc_objfile_data
.get (objfile
);
1020 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1021 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1024 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1028 /* Check the symbol name first as this can be done entirely without
1029 sending any query to the target. */
1030 symname
= msymbol
->natural_name ();
1031 if (symname
== NULL
)
1034 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1035 /* Not a method name. */
1040 /* Now that thinks are a bit sane, clean up the symname. */
1041 while ((strlen (symname
) + 1) >= tmplen
)
1043 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1044 tmp
= (char *) xrealloc (tmp
, tmplen
);
1046 strcpy (tmp
, symname
);
1048 if (parse_method (tmp
, &ntype
, &nclass
,
1049 &ncategory
, &nselector
) == NULL
)
1052 if ((type
!= '\0') && (ntype
!= type
))
1055 if ((theclass
!= NULL
)
1056 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1059 if ((category
!= NULL
) &&
1060 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1063 if ((selector
!= NULL
) &&
1064 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1067 symbol_names
->push_back (symname
);
1070 if (objc_csym
== NULL
)
1071 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1073 /* Count of ObjC methods in this objfile should be constant. */
1074 gdb_assert (*objc_csym
== objfile_csym
);
1078 /* Uniquify a vector of strings. */
1081 uniquify_strings (std::vector
<const char *> *strings
)
1083 if (strings
->empty ())
1086 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1087 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1092 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1094 * Input: a string representing a selector
1095 * a pointer to an array of symbol pointers
1096 * possibly a pointer to a symbol found by the caller.
1098 * Output: number of methods that implement that selector. Side
1099 * effects: The array of symbol pointers is filled with matching syms.
1101 * By analogy with function "find_methods" (symtab.c), builds a list
1102 * of symbols matching the ambiguous input, so that "decode_line_2"
1103 * (symtab.c) can list them and ask the user to choose one or more.
1104 * In this case the matches are objective c methods
1105 * ("implementations") matching an objective c selector.
1107 * Note that it is possible for a normal (c-style) function to have
1108 * the same name as an objective c selector. To prevent the selector
1109 * from eclipsing the function, we allow the caller (decode_line_1) to
1110 * search for such a function first, and if it finds one, pass it in
1111 * to us. We will then integrate it into the list. We also search
1112 * for one here, among the minsyms.
1114 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1115 * into two parts: debuggable (struct symbol) syms, and
1116 * non_debuggable (struct minimal_symbol) syms. The debuggable
1117 * ones will come first, before NUM_DEBUGGABLE (which will thus
1118 * be the index of the first non-debuggable one).
1122 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1125 char *theclass
= NULL
;
1126 char *category
= NULL
;
1127 char *selector
= NULL
;
1132 int selector_case
= 0;
1134 gdb_assert (symbol_names
!= NULL
);
1136 buf
= (char *) alloca (strlen (method
) + 1);
1137 strcpy (buf
, method
);
1138 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1142 strcpy (buf
, method
);
1143 tmp
= parse_selector (buf
, &selector
);
1151 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1153 /* If we hit the "selector" case, and we found some methods, then
1154 add the selector itself as a symbol, if it exists. */
1155 if (selector_case
&& !symbol_names
->empty ())
1157 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1161 symbol_names
->push_back (sym
->natural_name ());
1164 struct bound_minimal_symbol msym
1165 = lookup_minimal_symbol (selector
, 0, 0);
1167 if (msym
.minsym
!= NULL
)
1168 symbol_names
->push_back (msym
.minsym
->natural_name ());
1172 uniquify_strings (symbol_names
);
1174 return method
+ (tmp
- buf
);
1178 print_object_command (const char *args
, int from_tty
)
1180 struct value
*object
, *function
, *description
;
1181 CORE_ADDR string_addr
, object_addr
;
1185 if (!args
|| !*args
)
1187 "The 'print-object' command requires an argument (an Objective-C object)");
1190 expression_up expr
= parse_expression (args
);
1193 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1194 expr
.get (), &pc
, EVAL_NORMAL
);
1197 /* Validate the address for sanity. */
1198 object_addr
= value_as_long (object
);
1199 read_memory (object_addr
, &c
, 1);
1201 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1202 if (function
== NULL
)
1203 error (_("Unable to locate _NSPrintForDebugger in child process"));
1205 description
= call_function_by_hand (function
, NULL
, object
);
1207 string_addr
= value_as_long (description
);
1208 if (string_addr
== 0)
1209 error (_("object returns null description"));
1211 read_memory (string_addr
+ i
++, &c
, 1);
1214 { /* Read and print characters up to EOS. */
1216 printf_filtered ("%c", c
);
1217 read_memory (string_addr
+ i
++, &c
, 1);
1220 printf_filtered(_("<object returns empty description>"));
1221 printf_filtered ("\n");
1224 /* The data structure 'methcalls' is used to detect method calls (thru
1225 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1226 * and ultimately find the method being called.
1229 struct objc_methcall
{
1231 /* Return instance method to be called. */
1232 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1233 /* Start of pc range corresponding to method invocation. */
1235 /* End of pc range corresponding to method invocation. */
1239 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1240 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1241 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1242 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1244 static struct objc_methcall methcalls
[] = {
1245 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1246 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1247 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1248 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1249 { "_objc_getClass", NULL
, 0, 0},
1250 { "_objc_getMetaClass", NULL
, 0, 0}
1253 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1255 /* The following function, "find_objc_msgsend", fills in the data
1256 * structure "objc_msgs" by finding the addresses of each of the
1257 * (currently four) functions that it holds (of which objc_msgSend is
1258 * the first). This must be called each time symbols are loaded, in
1259 * case the functions have moved for some reason.
1263 find_objc_msgsend (void)
1267 for (i
= 0; i
< nmethcalls
; i
++)
1269 struct bound_minimal_symbol func
;
1271 /* Try both with and without underscore. */
1272 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1273 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1275 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1277 if (func
.minsym
== NULL
)
1279 methcalls
[i
].begin
= 0;
1280 methcalls
[i
].end
= 0;
1284 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1285 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1289 /* find_objc_msgcall (replaces pc_off_limits)
1291 * ALL that this function now does is to determine whether the input
1292 * address ("pc") is the address of one of the Objective-C message
1293 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1294 * if so, it returns the address of the method that will be called.
1296 * The old function "pc_off_limits" used to do a lot of other things
1297 * in addition, such as detecting shared library jump stubs and
1298 * returning the address of the shlib function that would be called.
1299 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1300 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1301 * dependent modules.
1305 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1311 if (f (pc
, new_pc
) == 0)
1314 catch (const gdb_exception
&ex
)
1316 exception_fprintf (gdb_stderr
, ex
,
1317 "Unable to determine target of "
1318 "Objective-C method call (ignoring):\n");
1325 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1329 find_objc_msgsend ();
1335 for (i
= 0; i
< nmethcalls
; i
++)
1336 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1338 if (methcalls
[i
].stop_at
!= NULL
)
1339 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1348 void _initialize_objc_language ();
1350 _initialize_objc_language ()
1352 add_info ("selectors", info_selectors_command
,
1353 _("All Objective-C selectors, or those matching REGEXP."));
1354 add_info ("classes", info_classes_command
,
1355 _("All Objective-C classes, or those matching REGEXP."));
1356 add_com ("print-object", class_vars
, print_object_command
,
1357 _("Ask an Objective-C object to print itself."));
1358 add_com_alias ("po", "print-object", class_vars
, 1);
1362 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1363 struct objc_method
*method
)
1365 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1367 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1368 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1369 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1372 static unsigned long
1373 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1375 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1377 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1381 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1382 unsigned long num
, struct objc_method
*method
)
1384 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1385 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1389 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1390 struct objc_object
*object
)
1392 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1394 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1398 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1399 struct objc_super
*super
)
1401 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1403 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1404 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1408 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1409 struct objc_class
*theclass
)
1411 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1413 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1414 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1415 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1416 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1417 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1418 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1420 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1421 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1422 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1423 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1427 find_implementation_from_class (struct gdbarch
*gdbarch
,
1428 CORE_ADDR theclass
, CORE_ADDR sel
)
1430 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1431 CORE_ADDR subclass
= theclass
;
1433 while (subclass
!= 0)
1436 struct objc_class class_str
;
1437 unsigned mlistnum
= 0;
1439 read_objc_class (gdbarch
, subclass
, &class_str
);
1444 unsigned long nmethods
;
1447 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1453 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1455 for (i
= 0; i
< nmethods
; i
++)
1457 struct objc_method meth_str
;
1459 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1461 if (meth_str
.name
== sel
)
1462 /* FIXME: hppa arch was doing a pointer dereference
1463 here. There needs to be a better way to do that. */
1464 return meth_str
.imp
;
1468 subclass
= class_str
.super_class
;
1475 find_implementation (struct gdbarch
*gdbarch
,
1476 CORE_ADDR object
, CORE_ADDR sel
)
1478 struct objc_object ostr
;
1482 read_objc_object (gdbarch
, object
, &ostr
);
1486 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1490 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1492 struct frame_info
*frame
= get_current_frame ();
1493 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1494 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1500 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1501 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1503 res
= find_implementation (gdbarch
, object
, sel
);
1512 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1514 struct frame_info
*frame
= get_current_frame ();
1515 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1516 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1522 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1523 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1525 res
= find_implementation (gdbarch
, object
, sel
);
1534 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1536 struct frame_info
*frame
= get_current_frame ();
1537 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1538 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1540 struct objc_super sstr
;
1546 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1547 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1549 read_objc_super (gdbarch
, super
, &sstr
);
1550 if (sstr
.theclass
== 0)
1553 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1562 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1564 struct frame_info
*frame
= get_current_frame ();
1565 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1566 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1568 struct objc_super sstr
;
1574 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1575 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1577 read_objc_super (gdbarch
, super
, &sstr
);
1578 if (sstr
.theclass
== 0)
1581 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);