1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2020 Free Software Foundation, Inc.
5 Contributed by Apple Computer, Inc.
6 Written by Michael Snyder.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
27 #include "parser-defs.h"
31 #include "objc-lang.h"
32 #include "complaints.h"
36 #include "target.h" /* for target_has_execution */
40 #include "gdb_regex.h"
45 #include "cli/cli-utils.h"
56 CORE_ADDR super_class
;
78 static const struct objfile_key
<unsigned int> objc_objfile_data
;
80 /* Lookup a structure type named "struct NAME", visible in lexical
81 block BLOCK. If NOERR is nonzero, return zero if NAME is not
85 lookup_struct_typedef (const char *name
, const struct block
*block
, int noerr
)
89 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
96 error (_("No struct type named %s."), name
);
98 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
103 error (_("This context has class, union or enum %s, not a struct."),
110 lookup_objc_class (struct gdbarch
*gdbarch
, const char *classname
)
112 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
113 struct value
* function
, *classval
;
115 if (! target_has_execution
)
117 /* Can't call into inferior to lookup class. */
121 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0).minsym
)
122 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
123 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym
)
124 function
= find_function_in_inferior("objc_lookup_class", NULL
);
127 complaint (_("no way to lookup Objective-C classes"));
131 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
132 classval
= value_coerce_array (classval
);
133 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
139 lookup_child_selector (struct gdbarch
*gdbarch
, const char *selname
)
141 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
142 struct value
* function
, *selstring
;
144 if (! target_has_execution
)
146 /* Can't call into inferior to lookup selector. */
150 if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym
)
151 function
= find_function_in_inferior("sel_getUid", NULL
);
152 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym
)
153 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
156 complaint (_("no way to lookup Objective-C selectors"));
160 selstring
= value_coerce_array (value_string (selname
,
161 strlen (selname
) + 1,
163 return value_as_long (call_function_by_hand (function
, NULL
, selstring
));
167 value_nsstring (struct gdbarch
*gdbarch
, char *ptr
, int len
)
169 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
170 struct value
*stringValue
[3];
171 struct value
*function
, *nsstringValue
;
175 if (!target_has_execution
)
176 return 0; /* Can't call into inferior to create NSString. */
178 stringValue
[2] = value_string(ptr
, len
, char_type
);
179 stringValue
[2] = value_coerce_array(stringValue
[2]);
180 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
181 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym
)
183 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
184 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
186 else if (lookup_minimal_symbol("istr", 0, 0).minsym
)
188 function
= find_function_in_inferior("istr", NULL
);
189 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
191 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym
)
194 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
195 type
= builtin_type (gdbarch
)->builtin_long
;
197 stringValue
[0] = value_from_longest
198 (type
, lookup_objc_class (gdbarch
, "NSString"));
199 stringValue
[1] = value_from_longest
200 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
201 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
);
204 error (_("NSString: internal error -- no way to create new NSString"));
206 sym
= lookup_struct_typedef("NSString", 0, 1);
208 sym
= lookup_struct_typedef("NXString", 0, 1);
210 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
212 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
214 deprecated_set_value_type (nsstringValue
, type
);
215 return nsstringValue
;
218 /* Objective-C name demangling. */
221 objc_demangle (const char *mangled
, int options
)
223 char *demangled
, *cp
;
225 if (mangled
[0] == '_' &&
226 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
229 cp
= demangled
= (char *) xmalloc (strlen (mangled
) + 2);
231 if (mangled
[1] == 'i')
232 *cp
++ = '-'; /* for instance method */
234 *cp
++ = '+'; /* for class method */
236 *cp
++ = '['; /* opening left brace */
237 strcpy(cp
, mangled
+3); /* Tack on the rest of the mangled name. */
239 while (*cp
&& *cp
== '_')
240 cp
++; /* Skip any initial underbars in class
243 cp
= strchr(cp
, '_');
244 if (!cp
) /* Find first non-initial underbar. */
246 xfree(demangled
); /* not mangled name */
249 if (cp
[1] == '_') /* Easy case: no category name. */
251 *cp
++ = ' '; /* Replace two '_' with one ' '. */
252 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
256 *cp
++ = '('; /* Less easy case: category name. */
257 cp
= strchr(cp
, '_');
260 xfree(demangled
); /* not mangled name */
264 *cp
++ = ' '; /* Overwriting 1st char of method name... */
265 strcpy(cp
, mangled
+ (cp
- demangled
)); /* Get it back. */
268 while (*cp
&& *cp
== '_')
269 cp
++; /* Skip any initial underbars in
274 *cp
= ':'; /* Replace remaining '_' with ':'. */
276 *cp
++ = ']'; /* closing right brace */
277 *cp
++ = 0; /* string terminator */
281 return NULL
; /* Not an objc mangled name. */
285 /* Table mapping opcodes into strings for printing operators
286 and precedences of the operators. */
288 static const struct op_print objc_op_print_tab
[] =
290 {",", BINOP_COMMA
, PREC_COMMA
, 0},
291 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
292 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
293 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
294 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
295 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
296 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
297 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
298 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
299 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
300 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
301 {">", BINOP_GTR
, PREC_ORDER
, 0},
302 {"<", BINOP_LESS
, PREC_ORDER
, 0},
303 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
304 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
305 {"+", BINOP_ADD
, PREC_ADD
, 0},
306 {"-", BINOP_SUB
, PREC_ADD
, 0},
307 {"*", BINOP_MUL
, PREC_MUL
, 0},
308 {"/", BINOP_DIV
, PREC_MUL
, 0},
309 {"%", BINOP_REM
, PREC_MUL
, 0},
310 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
311 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
312 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
313 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
314 {"*", UNOP_IND
, PREC_PREFIX
, 0},
315 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
316 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
317 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
318 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
319 {NULL
, OP_NULL
, PREC_NULL
, 0}
322 static const char *objc_extensions
[] =
327 /* Constant data representing the Objective-C language. */
329 extern const struct language_data objc_language_data
=
331 "objective-c", /* Language name */
339 &exp_descriptor_standard
,
342 c_printchar
, /* Print a character constant */
343 c_printstr
, /* Function to print string constant */
345 c_print_typedef
, /* Print a typedef using appropriate syntax */
346 "self", /* name_of_this */
347 false, /* la_store_sym_names_in_linkage_form_p */
348 objc_op_print_tab
, /* Expression operators for printing */
349 1, /* C-style arrays */
350 0, /* String lower bound */
353 "{...}" /* la_struct_too_deep_ellipsis */
356 /* Class representing the Objective-C language. */
358 class objc_language
: public language_defn
362 : language_defn (language_objc
, objc_language_data
)
365 /* See language.h. */
366 void language_arch_info (struct gdbarch
*gdbarch
,
367 struct language_arch_info
*lai
) const override
369 c_language_arch_info (gdbarch
, lai
);
372 /* See language.h. */
373 bool sniff_from_mangled_name (const char *mangled
,
374 char **demangled
) const override
376 *demangled
= objc_demangle (mangled
, 0);
377 return *demangled
!= NULL
;
380 /* See language.h. */
382 char *demangle (const char *mangled
, int options
) const override
384 return objc_demangle (mangled
, options
);
387 /* See language.h. */
389 void print_type (struct type
*type
, const char *varstring
,
390 struct ui_file
*stream
, int show
, int level
,
391 const struct type_print_options
*flags
) const override
393 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
396 /* See language.h. */
398 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
399 CORE_ADDR stop_pc
) const override
401 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
402 CORE_ADDR real_stop_pc
;
403 CORE_ADDR method_stop_pc
;
405 /* Determine if we are currently in the Objective-C dispatch function.
406 If so, get the address of the method function that the dispatcher
407 would call and use that as the function to step into instead. Also
408 skip over the trampoline for the function (if any). This is better
409 for the user since they are only interested in stepping into the
410 method function anyway. */
412 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
414 if (real_stop_pc
!= 0)
415 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
417 find_objc_msgcall (stop_pc
, &method_stop_pc
);
421 real_stop_pc
= gdbarch_skip_trampoline_code
422 (gdbarch
, frame
, method_stop_pc
);
423 if (real_stop_pc
== 0)
424 real_stop_pc
= method_stop_pc
;
431 /* Single instance of the class representing the Objective-C language. */
433 static objc_language objc_language_defn
;
437 * Following functions help construct Objective-C message calls.
440 struct selname
/* For parsing Objective-C. */
442 struct selname
*next
;
447 static int msglist_len
;
448 static struct selname
*selname_chain
;
449 static char *msglist_sel
;
454 struct selname
*newobj
= XNEW (struct selname
);
456 newobj
->next
= selname_chain
;
457 newobj
->msglist_len
= msglist_len
;
458 newobj
->msglist_sel
= msglist_sel
;
460 msglist_sel
= (char *)xmalloc(1);
462 selname_chain
= newobj
;
466 add_msglist(struct stoken
*str
, int addcolon
)
472 if (str
== 0) /* Unnamed arg, or... */
474 if (addcolon
== 0) /* variable number of args. */
487 len
= plen
+ strlen(msglist_sel
) + 2;
488 s
= (char *)xmalloc(len
);
489 strcpy(s
, msglist_sel
);
504 end_msglist (struct parser_state
*ps
)
506 int val
= msglist_len
;
507 struct selname
*sel
= selname_chain
;
508 char *p
= msglist_sel
;
511 selname_chain
= sel
->next
;
512 msglist_len
= sel
->msglist_len
;
513 msglist_sel
= sel
->msglist_sel
;
514 selid
= lookup_child_selector (ps
->gdbarch (), p
);
516 error (_("Can't find selector \"%s\""), p
);
517 write_exp_elt_longcst (ps
, selid
);
519 write_exp_elt_longcst (ps
, val
); /* Number of args */
526 * Function: specialcmp (const char *a, const char *b)
528 * Special strcmp: treats ']' and ' ' as end-of-string.
529 * Used for qsorting lists of objc methods (either by class or selector).
533 specialcmp (const char *a
, const char *b
)
535 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
541 if (*a
&& *a
!= ' ' && *a
!= ']')
542 return 1; /* a is longer therefore greater. */
543 if (*b
&& *b
!= ' ' && *b
!= ']')
544 return -1; /* a is shorter therefore lesser. */
545 return 0; /* a and b are identical. */
549 * Function: compare_selectors (const void *, const void *)
551 * Comparison function for use with qsort. Arguments are symbols or
552 * msymbols Compares selector part of objc method name alphabetically.
556 compare_selectors (const void *a
, const void *b
)
558 const char *aname
, *bname
;
560 aname
= (*(struct symbol
**) a
)->print_name ();
561 bname
= (*(struct symbol
**) b
)->print_name ();
562 if (aname
== NULL
|| bname
== NULL
)
563 error (_("internal: compare_selectors(1)"));
565 aname
= strchr(aname
, ' ');
566 bname
= strchr(bname
, ' ');
567 if (aname
== NULL
|| bname
== NULL
)
568 error (_("internal: compare_selectors(2)"));
570 return specialcmp (aname
+1, bname
+1);
574 * Function: selectors_info (regexp, from_tty)
576 * Implements the "Info selectors" command. Takes an optional regexp
577 * arg. Lists all objective c selectors that match the regexp. Works
578 * by grepping thru all symbols for objective c methods. Output list
579 * is sorted and uniqued.
583 info_selectors_command (const char *regexp
, int from_tty
)
592 struct symbol
**sym_arr
;
596 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
599 if (*regexp
== '+' || *regexp
== '-')
600 { /* User wants only class methods or only instance methods. */
601 plusminus
= *regexp
++;
602 while (*regexp
== ' ' || *regexp
== '\t')
606 strcpy(myregexp
, ".*]");
609 /* Allow a few extra bytes because of the strcat below. */
610 if (sizeof (myregexp
) < strlen (regexp
) + 4)
611 error (_("Regexp is too long: %s"), regexp
);
612 strcpy(myregexp
, regexp
);
613 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
614 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
616 strcat(myregexp
, ".*]");
622 val
= re_comp (myregexp
);
624 error (_("Invalid regexp (%s): %s"), val
, regexp
);
627 /* First time thru is JUST to get max length and count. */
628 for (objfile
*objfile
: current_program_space
->objfiles ())
630 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
633 name
= msymbol
->natural_name ();
635 && (name
[0] == '-' || name
[0] == '+')
636 && name
[1] == '[') /* Got a method name. */
638 /* Filter for class/instance methods. */
639 if (plusminus
&& name
[0] != plusminus
)
641 /* Find selector part. */
642 name
= (char *) strchr (name
+2, ' ');
645 complaint (_("Bad method name '%s'"),
646 msymbol
->natural_name ());
649 if (regexp
== NULL
|| re_exec(++name
) != 0)
651 const char *mystart
= name
;
652 const char *myend
= strchr (mystart
, ']');
654 if (myend
&& (myend
- mystart
> maxlen
))
655 maxlen
= myend
- mystart
; /* Get longest selector. */
663 printf_filtered (_("Selectors matching \"%s\":\n\n"),
664 regexp
? regexp
: "*");
666 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
668 for (objfile
*objfile
: current_program_space
->objfiles ())
670 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
673 name
= msymbol
->natural_name ();
675 (name
[0] == '-' || name
[0] == '+') &&
676 name
[1] == '[') /* Got a method name. */
678 /* Filter for class/instance methods. */
679 if (plusminus
&& name
[0] != plusminus
)
681 /* Find selector part. */
682 name
= (char *) strchr(name
+2, ' ');
683 if (regexp
== NULL
|| re_exec(++name
) != 0)
684 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
689 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
691 /* Prevent compare on first iteration. */
693 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
698 name
= sym_arr
[ix
]->natural_name ();
699 name
= strchr (name
, ' ') + 1;
700 if (p
[0] && specialcmp(name
, p
) == 0)
701 continue; /* Seen this one already (not unique). */
703 /* Copy selector part. */
704 while (*name
&& *name
!= ']')
707 /* Print in columns. */
708 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
713 printf_filtered (_("No selectors matching \"%s\"\n"),
714 regexp
? regexp
: "*");
718 * Function: compare_classes (const void *, const void *)
720 * Comparison function for use with qsort. Arguments are symbols or
721 * msymbols Compares class part of objc method name alphabetically.
725 compare_classes (const void *a
, const void *b
)
727 const char *aname
, *bname
;
729 aname
= (*(struct symbol
**) a
)->print_name ();
730 bname
= (*(struct symbol
**) b
)->print_name ();
731 if (aname
== NULL
|| bname
== NULL
)
732 error (_("internal: compare_classes(1)"));
734 return specialcmp (aname
+1, bname
+1);
738 * Function: classes_info(regexp, from_tty)
740 * Implements the "info classes" command for objective c classes.
741 * Lists all objective c classes that match the optional regexp.
742 * Works by grepping thru the list of objective c methods. List will
743 * be sorted and uniqued (since one class may have many methods).
744 * BUGS: will not list a class that has no methods.
748 info_classes_command (const char *regexp
, int from_tty
)
757 struct symbol
**sym_arr
;
760 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
763 /* Allow a few extra bytes because of the strcat below. */
764 if (sizeof (myregexp
) < strlen (regexp
) + 4)
765 error (_("Regexp is too long: %s"), regexp
);
766 strcpy(myregexp
, regexp
);
767 if (myregexp
[strlen(myregexp
) - 1] == '$')
768 /* In the method name, the end of the class name is marked by ' '. */
769 myregexp
[strlen(myregexp
) - 1] = ' ';
771 strcat(myregexp
, ".* ");
776 val
= re_comp (myregexp
);
778 error (_("Invalid regexp (%s): %s"), val
, regexp
);
781 /* First time thru is JUST to get max length and count. */
782 for (objfile
*objfile
: current_program_space
->objfiles ())
784 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
787 name
= msymbol
->natural_name ();
789 (name
[0] == '-' || name
[0] == '+') &&
790 name
[1] == '[') /* Got a method name. */
791 if (regexp
== NULL
|| re_exec(name
+2) != 0)
793 /* Compute length of classname part. */
794 const char *mystart
= name
+ 2;
795 const char *myend
= strchr (mystart
, ' ');
797 if (myend
&& (myend
- mystart
> maxlen
))
798 maxlen
= myend
- mystart
;
805 printf_filtered (_("Classes matching \"%s\":\n\n"),
806 regexp
? regexp
: "*");
807 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
809 for (objfile
*objfile
: current_program_space
->objfiles ())
811 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
814 name
= msymbol
->natural_name ();
816 (name
[0] == '-' || name
[0] == '+') &&
817 name
[1] == '[') /* Got a method name. */
818 if (regexp
== NULL
|| re_exec(name
+2) != 0)
819 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
823 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
825 /* Prevent compare on first iteration. */
827 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
832 name
= sym_arr
[ix
]->natural_name ();
834 if (p
[0] && specialcmp(name
, p
) == 0)
835 continue; /* Seen this one already (not unique). */
837 /* Copy class part of method name. */
838 while (*name
&& *name
!= ' ')
841 /* Print in columns. */
842 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
847 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
851 parse_selector (char *method
, char **selector
)
857 char *nselector
= NULL
;
859 gdb_assert (selector
!= NULL
);
863 s1
= skip_spaces (s1
);
869 s1
= skip_spaces (s1
);
876 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
878 else if (isspace (*s2
))
880 else if ((*s2
== '\0') || (*s2
== '\''))
888 s2
= skip_spaces (s2
);
893 s2
= skip_spaces (s2
);
896 if (selector
!= NULL
)
897 *selector
= nselector
;
903 parse_method (char *method
, char *type
, char **theclass
,
904 char **category
, char **selector
)
912 char *ncategory
= NULL
;
913 char *nselector
= NULL
;
915 gdb_assert (type
!= NULL
);
916 gdb_assert (theclass
!= NULL
);
917 gdb_assert (category
!= NULL
);
918 gdb_assert (selector
!= NULL
);
922 s1
= skip_spaces (s1
);
928 s1
= skip_spaces (s1
);
930 if ((s1
[0] == '+') || (s1
[0] == '-'))
933 s1
= skip_spaces (s1
);
940 while (isalnum (*s1
) || (*s1
== '_'))
944 s2
= skip_spaces (s2
);
949 s2
= skip_spaces (s2
);
951 while (isalnum (*s2
) || (*s2
== '_'))
956 /* Truncate the class name now that we're not using the open paren. */
964 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
966 else if (isspace (*s2
))
977 s2
= skip_spaces (s2
);
983 s2
= skip_spaces (s2
);
988 if (theclass
!= NULL
)
990 if (category
!= NULL
)
991 *category
= ncategory
;
992 if (selector
!= NULL
)
993 *selector
= nselector
;
999 find_methods (char type
, const char *theclass
, const char *category
,
1000 const char *selector
,
1001 std::vector
<const char *> *symbol_names
)
1003 const char *symname
= NULL
;
1006 char *nclass
= NULL
;
1007 char *ncategory
= NULL
;
1008 char *nselector
= NULL
;
1010 static char *tmp
= NULL
;
1011 static unsigned int tmplen
= 0;
1013 gdb_assert (symbol_names
!= NULL
);
1015 for (objfile
*objfile
: current_program_space
->objfiles ())
1017 unsigned int *objc_csym
;
1019 /* The objfile_csym variable counts the number of ObjC methods
1020 that this objfile defines. We save that count as a private
1021 objfile data. If we have already determined that this objfile
1022 provides no ObjC methods, we can skip it entirely. */
1024 unsigned int objfile_csym
= 0;
1026 objc_csym
= objc_objfile_data
.get (objfile
);
1027 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1028 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1031 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1035 /* Check the symbol name first as this can be done entirely without
1036 sending any query to the target. */
1037 symname
= msymbol
->natural_name ();
1038 if (symname
== NULL
)
1041 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1042 /* Not a method name. */
1047 /* Now that thinks are a bit sane, clean up the symname. */
1048 while ((strlen (symname
) + 1) >= tmplen
)
1050 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1051 tmp
= (char *) xrealloc (tmp
, tmplen
);
1053 strcpy (tmp
, symname
);
1055 if (parse_method (tmp
, &ntype
, &nclass
,
1056 &ncategory
, &nselector
) == NULL
)
1059 if ((type
!= '\0') && (ntype
!= type
))
1062 if ((theclass
!= NULL
)
1063 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1066 if ((category
!= NULL
) &&
1067 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1070 if ((selector
!= NULL
) &&
1071 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1074 symbol_names
->push_back (symname
);
1077 if (objc_csym
== NULL
)
1078 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1080 /* Count of ObjC methods in this objfile should be constant. */
1081 gdb_assert (*objc_csym
== objfile_csym
);
1085 /* Uniquify a vector of strings. */
1088 uniquify_strings (std::vector
<const char *> *strings
)
1090 if (strings
->empty ())
1093 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1094 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1099 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1101 * Input: a string representing a selector
1102 * a pointer to an array of symbol pointers
1103 * possibly a pointer to a symbol found by the caller.
1105 * Output: number of methods that implement that selector. Side
1106 * effects: The array of symbol pointers is filled with matching syms.
1108 * By analogy with function "find_methods" (symtab.c), builds a list
1109 * of symbols matching the ambiguous input, so that "decode_line_2"
1110 * (symtab.c) can list them and ask the user to choose one or more.
1111 * In this case the matches are objective c methods
1112 * ("implementations") matching an objective c selector.
1114 * Note that it is possible for a normal (c-style) function to have
1115 * the same name as an objective c selector. To prevent the selector
1116 * from eclipsing the function, we allow the caller (decode_line_1) to
1117 * search for such a function first, and if it finds one, pass it in
1118 * to us. We will then integrate it into the list. We also search
1119 * for one here, among the minsyms.
1121 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1122 * into two parts: debuggable (struct symbol) syms, and
1123 * non_debuggable (struct minimal_symbol) syms. The debuggable
1124 * ones will come first, before NUM_DEBUGGABLE (which will thus
1125 * be the index of the first non-debuggable one).
1129 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1132 char *theclass
= NULL
;
1133 char *category
= NULL
;
1134 char *selector
= NULL
;
1139 int selector_case
= 0;
1141 gdb_assert (symbol_names
!= NULL
);
1143 buf
= (char *) alloca (strlen (method
) + 1);
1144 strcpy (buf
, method
);
1145 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1149 strcpy (buf
, method
);
1150 tmp
= parse_selector (buf
, &selector
);
1158 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1160 /* If we hit the "selector" case, and we found some methods, then
1161 add the selector itself as a symbol, if it exists. */
1162 if (selector_case
&& !symbol_names
->empty ())
1164 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1168 symbol_names
->push_back (sym
->natural_name ());
1171 struct bound_minimal_symbol msym
1172 = lookup_minimal_symbol (selector
, 0, 0);
1174 if (msym
.minsym
!= NULL
)
1175 symbol_names
->push_back (msym
.minsym
->natural_name ());
1179 uniquify_strings (symbol_names
);
1181 return method
+ (tmp
- buf
);
1185 print_object_command (const char *args
, int from_tty
)
1187 struct value
*object
, *function
, *description
;
1188 CORE_ADDR string_addr
, object_addr
;
1192 if (!args
|| !*args
)
1194 "The 'print-object' command requires an argument (an Objective-C object)");
1197 expression_up expr
= parse_expression (args
);
1200 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1201 expr
.get (), &pc
, EVAL_NORMAL
);
1204 /* Validate the address for sanity. */
1205 object_addr
= value_as_long (object
);
1206 read_memory (object_addr
, &c
, 1);
1208 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1209 if (function
== NULL
)
1210 error (_("Unable to locate _NSPrintForDebugger in child process"));
1212 description
= call_function_by_hand (function
, NULL
, object
);
1214 string_addr
= value_as_long (description
);
1215 if (string_addr
== 0)
1216 error (_("object returns null description"));
1218 read_memory (string_addr
+ i
++, &c
, 1);
1221 { /* Read and print characters up to EOS. */
1223 printf_filtered ("%c", c
);
1224 read_memory (string_addr
+ i
++, &c
, 1);
1227 printf_filtered(_("<object returns empty description>"));
1228 printf_filtered ("\n");
1231 /* The data structure 'methcalls' is used to detect method calls (thru
1232 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1233 * and ultimately find the method being called.
1236 struct objc_methcall
{
1238 /* Return instance method to be called. */
1239 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1240 /* Start of pc range corresponding to method invocation. */
1242 /* End of pc range corresponding to method invocation. */
1246 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1247 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1248 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1249 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1251 static struct objc_methcall methcalls
[] = {
1252 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1253 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1254 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1255 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1256 { "_objc_getClass", NULL
, 0, 0},
1257 { "_objc_getMetaClass", NULL
, 0, 0}
1260 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1262 /* The following function, "find_objc_msgsend", fills in the data
1263 * structure "objc_msgs" by finding the addresses of each of the
1264 * (currently four) functions that it holds (of which objc_msgSend is
1265 * the first). This must be called each time symbols are loaded, in
1266 * case the functions have moved for some reason.
1270 find_objc_msgsend (void)
1274 for (i
= 0; i
< nmethcalls
; i
++)
1276 struct bound_minimal_symbol func
;
1278 /* Try both with and without underscore. */
1279 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1280 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1282 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1284 if (func
.minsym
== NULL
)
1286 methcalls
[i
].begin
= 0;
1287 methcalls
[i
].end
= 0;
1291 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1292 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1296 /* find_objc_msgcall (replaces pc_off_limits)
1298 * ALL that this function now does is to determine whether the input
1299 * address ("pc") is the address of one of the Objective-C message
1300 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1301 * if so, it returns the address of the method that will be called.
1303 * The old function "pc_off_limits" used to do a lot of other things
1304 * in addition, such as detecting shared library jump stubs and
1305 * returning the address of the shlib function that would be called.
1306 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1307 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1308 * dependent modules.
1312 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1318 if (f (pc
, new_pc
) == 0)
1321 catch (const gdb_exception
&ex
)
1323 exception_fprintf (gdb_stderr
, ex
,
1324 "Unable to determine target of "
1325 "Objective-C method call (ignoring):\n");
1332 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1336 find_objc_msgsend ();
1342 for (i
= 0; i
< nmethcalls
; i
++)
1343 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1345 if (methcalls
[i
].stop_at
!= NULL
)
1346 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1355 void _initialize_objc_language ();
1357 _initialize_objc_language ()
1359 add_info ("selectors", info_selectors_command
,
1360 _("All Objective-C selectors, or those matching REGEXP."));
1361 add_info ("classes", info_classes_command
,
1362 _("All Objective-C classes, or those matching REGEXP."));
1363 add_com ("print-object", class_vars
, print_object_command
,
1364 _("Ask an Objective-C object to print itself."));
1365 add_com_alias ("po", "print-object", class_vars
, 1);
1369 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1370 struct objc_method
*method
)
1372 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1374 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1375 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1376 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1379 static unsigned long
1380 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1382 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1384 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1388 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1389 unsigned long num
, struct objc_method
*method
)
1391 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1392 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1396 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1397 struct objc_object
*object
)
1399 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1401 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1405 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1406 struct objc_super
*super
)
1408 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1410 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1411 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1415 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1416 struct objc_class
*theclass
)
1418 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1420 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1421 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1422 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1423 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1424 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1425 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1427 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1428 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1429 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1430 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1434 find_implementation_from_class (struct gdbarch
*gdbarch
,
1435 CORE_ADDR theclass
, CORE_ADDR sel
)
1437 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1438 CORE_ADDR subclass
= theclass
;
1440 while (subclass
!= 0)
1443 struct objc_class class_str
;
1444 unsigned mlistnum
= 0;
1446 read_objc_class (gdbarch
, subclass
, &class_str
);
1451 unsigned long nmethods
;
1454 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1460 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1462 for (i
= 0; i
< nmethods
; i
++)
1464 struct objc_method meth_str
;
1466 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1468 if (meth_str
.name
== sel
)
1469 /* FIXME: hppa arch was doing a pointer dereference
1470 here. There needs to be a better way to do that. */
1471 return meth_str
.imp
;
1475 subclass
= class_str
.super_class
;
1482 find_implementation (struct gdbarch
*gdbarch
,
1483 CORE_ADDR object
, CORE_ADDR sel
)
1485 struct objc_object ostr
;
1489 read_objc_object (gdbarch
, object
, &ostr
);
1493 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1497 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1499 struct frame_info
*frame
= get_current_frame ();
1500 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1501 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1507 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1508 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1510 res
= find_implementation (gdbarch
, object
, sel
);
1519 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1521 struct frame_info
*frame
= get_current_frame ();
1522 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1523 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1529 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1530 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1532 res
= find_implementation (gdbarch
, object
, sel
);
1541 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1543 struct frame_info
*frame
= get_current_frame ();
1544 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1545 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1547 struct objc_super sstr
;
1553 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1554 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1556 read_objc_super (gdbarch
, super
, &sstr
);
1557 if (sstr
.theclass
== 0)
1560 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1569 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1571 struct frame_info
*frame
= get_current_frame ();
1572 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1573 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1575 struct objc_super sstr
;
1581 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1582 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1584 read_objc_super (gdbarch
, super
, &sstr
);
1585 if (sstr
.theclass
== 0)
1588 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);