1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2020 Free Software Foundation, Inc.
5 Contributed by Apple Computer, Inc.
6 Written by Michael Snyder.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
27 #include "parser-defs.h"
31 #include "objc-lang.h"
32 #include "complaints.h"
36 #include "target.h" /* for target_has_execution */
40 #include "gdb_regex.h"
45 #include "cli/cli-utils.h"
56 CORE_ADDR super_class
;
78 static const struct objfile_key
<unsigned int> objc_objfile_data
;
80 /* Lookup a structure type named "struct NAME", visible in lexical
81 block BLOCK. If NOERR is nonzero, return zero if NAME is not
85 lookup_struct_typedef (const char *name
, const struct block
*block
, int noerr
)
89 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
96 error (_("No struct type named %s."), name
);
98 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
103 error (_("This context has class, union or enum %s, not a struct."),
110 lookup_objc_class (struct gdbarch
*gdbarch
, const char *classname
)
112 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
113 struct value
* function
, *classval
;
115 if (! target_has_execution
)
117 /* Can't call into inferior to lookup class. */
121 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0).minsym
)
122 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
123 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym
)
124 function
= find_function_in_inferior("objc_lookup_class", NULL
);
127 complaint (_("no way to lookup Objective-C classes"));
131 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
132 classval
= value_coerce_array (classval
);
133 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
139 lookup_child_selector (struct gdbarch
*gdbarch
, const char *selname
)
141 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
142 struct value
* function
, *selstring
;
144 if (! target_has_execution
)
146 /* Can't call into inferior to lookup selector. */
150 if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym
)
151 function
= find_function_in_inferior("sel_getUid", NULL
);
152 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym
)
153 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
156 complaint (_("no way to lookup Objective-C selectors"));
160 selstring
= value_coerce_array (value_string (selname
,
161 strlen (selname
) + 1,
163 return value_as_long (call_function_by_hand (function
, NULL
, selstring
));
167 value_nsstring (struct gdbarch
*gdbarch
, char *ptr
, int len
)
169 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
170 struct value
*stringValue
[3];
171 struct value
*function
, *nsstringValue
;
175 if (!target_has_execution
)
176 return 0; /* Can't call into inferior to create NSString. */
178 stringValue
[2] = value_string(ptr
, len
, char_type
);
179 stringValue
[2] = value_coerce_array(stringValue
[2]);
180 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
181 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym
)
183 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
184 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
186 else if (lookup_minimal_symbol("istr", 0, 0).minsym
)
188 function
= find_function_in_inferior("istr", NULL
);
189 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
191 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym
)
194 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
195 type
= builtin_type (gdbarch
)->builtin_long
;
197 stringValue
[0] = value_from_longest
198 (type
, lookup_objc_class (gdbarch
, "NSString"));
199 stringValue
[1] = value_from_longest
200 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
201 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
);
204 error (_("NSString: internal error -- no way to create new NSString"));
206 sym
= lookup_struct_typedef("NSString", 0, 1);
208 sym
= lookup_struct_typedef("NXString", 0, 1);
210 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
212 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
214 deprecated_set_value_type (nsstringValue
, type
);
215 return nsstringValue
;
218 /* Objective-C name demangling. */
221 objc_demangle (const char *mangled
, int options
)
223 char *demangled
, *cp
;
225 if (mangled
[0] == '_' &&
226 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
229 cp
= demangled
= (char *) xmalloc (strlen (mangled
) + 2);
231 if (mangled
[1] == 'i')
232 *cp
++ = '-'; /* for instance method */
234 *cp
++ = '+'; /* for class method */
236 *cp
++ = '['; /* opening left brace */
237 strcpy(cp
, mangled
+3); /* Tack on the rest of the mangled name. */
239 while (*cp
&& *cp
== '_')
240 cp
++; /* Skip any initial underbars in class
243 cp
= strchr(cp
, '_');
244 if (!cp
) /* Find first non-initial underbar. */
246 xfree(demangled
); /* not mangled name */
249 if (cp
[1] == '_') /* Easy case: no category name. */
251 *cp
++ = ' '; /* Replace two '_' with one ' '. */
252 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
256 *cp
++ = '('; /* Less easy case: category name. */
257 cp
= strchr(cp
, '_');
260 xfree(demangled
); /* not mangled name */
264 *cp
++ = ' '; /* Overwriting 1st char of method name... */
265 strcpy(cp
, mangled
+ (cp
- demangled
)); /* Get it back. */
268 while (*cp
&& *cp
== '_')
269 cp
++; /* Skip any initial underbars in
274 *cp
= ':'; /* Replace remaining '_' with ':'. */
276 *cp
++ = ']'; /* closing right brace */
277 *cp
++ = 0; /* string terminator */
281 return NULL
; /* Not an objc mangled name. */
285 /* Table mapping opcodes into strings for printing operators
286 and precedences of the operators. */
288 static const struct op_print objc_op_print_tab
[] =
290 {",", BINOP_COMMA
, PREC_COMMA
, 0},
291 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
292 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
293 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
294 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
295 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
296 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
297 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
298 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
299 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
300 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
301 {">", BINOP_GTR
, PREC_ORDER
, 0},
302 {"<", BINOP_LESS
, PREC_ORDER
, 0},
303 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
304 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
305 {"+", BINOP_ADD
, PREC_ADD
, 0},
306 {"-", BINOP_SUB
, PREC_ADD
, 0},
307 {"*", BINOP_MUL
, PREC_MUL
, 0},
308 {"/", BINOP_DIV
, PREC_MUL
, 0},
309 {"%", BINOP_REM
, PREC_MUL
, 0},
310 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
311 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
312 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
313 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
314 {"*", UNOP_IND
, PREC_PREFIX
, 0},
315 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
316 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
317 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
318 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
319 {NULL
, OP_NULL
, PREC_NULL
, 0}
322 static const char *objc_extensions
[] =
327 /* Constant data representing the Objective-C language. */
329 extern const struct language_data objc_language_data
=
331 "objective-c", /* Language name */
339 &exp_descriptor_standard
,
342 c_printchar
, /* Print a character constant */
343 c_printstr
, /* Function to print string constant */
345 c_print_typedef
, /* Print a typedef using appropriate syntax */
346 c_value_print_inner
, /* la_value_print_inner */
347 "self", /* name_of_this */
348 false, /* la_store_sym_names_in_linkage_form_p */
349 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
350 objc_op_print_tab
, /* Expression operators for printing */
351 1, /* C-style arrays */
352 0, /* String lower bound */
355 "{...}" /* la_struct_too_deep_ellipsis */
358 /* Class representing the Objective-C language. */
360 class objc_language
: public language_defn
364 : language_defn (language_objc
, objc_language_data
)
367 /* See language.h. */
368 void language_arch_info (struct gdbarch
*gdbarch
,
369 struct language_arch_info
*lai
) const override
371 c_language_arch_info (gdbarch
, lai
);
374 /* See language.h. */
375 bool sniff_from_mangled_name (const char *mangled
,
376 char **demangled
) const override
378 *demangled
= objc_demangle (mangled
, 0);
379 return *demangled
!= NULL
;
382 /* See language.h. */
384 char *demangle (const char *mangled
, int options
) const override
386 return objc_demangle (mangled
, options
);
389 /* See language.h. */
391 void print_type (struct type
*type
, const char *varstring
,
392 struct ui_file
*stream
, int show
, int level
,
393 const struct type_print_options
*flags
) const override
395 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
398 /* See language.h. */
400 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
401 CORE_ADDR stop_pc
) const override
403 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
404 CORE_ADDR real_stop_pc
;
405 CORE_ADDR method_stop_pc
;
407 /* Determine if we are currently in the Objective-C dispatch function.
408 If so, get the address of the method function that the dispatcher
409 would call and use that as the function to step into instead. Also
410 skip over the trampoline for the function (if any). This is better
411 for the user since they are only interested in stepping into the
412 method function anyway. */
414 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
416 if (real_stop_pc
!= 0)
417 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
419 find_objc_msgcall (stop_pc
, &method_stop_pc
);
423 real_stop_pc
= gdbarch_skip_trampoline_code
424 (gdbarch
, frame
, method_stop_pc
);
425 if (real_stop_pc
== 0)
426 real_stop_pc
= method_stop_pc
;
433 /* Single instance of the class representing the Objective-C language. */
435 static objc_language objc_language_defn
;
439 * Following functions help construct Objective-C message calls.
442 struct selname
/* For parsing Objective-C. */
444 struct selname
*next
;
449 static int msglist_len
;
450 static struct selname
*selname_chain
;
451 static char *msglist_sel
;
456 struct selname
*newobj
= XNEW (struct selname
);
458 newobj
->next
= selname_chain
;
459 newobj
->msglist_len
= msglist_len
;
460 newobj
->msglist_sel
= msglist_sel
;
462 msglist_sel
= (char *)xmalloc(1);
464 selname_chain
= newobj
;
468 add_msglist(struct stoken
*str
, int addcolon
)
474 if (str
== 0) /* Unnamed arg, or... */
476 if (addcolon
== 0) /* variable number of args. */
489 len
= plen
+ strlen(msglist_sel
) + 2;
490 s
= (char *)xmalloc(len
);
491 strcpy(s
, msglist_sel
);
506 end_msglist (struct parser_state
*ps
)
508 int val
= msglist_len
;
509 struct selname
*sel
= selname_chain
;
510 char *p
= msglist_sel
;
513 selname_chain
= sel
->next
;
514 msglist_len
= sel
->msglist_len
;
515 msglist_sel
= sel
->msglist_sel
;
516 selid
= lookup_child_selector (ps
->gdbarch (), p
);
518 error (_("Can't find selector \"%s\""), p
);
519 write_exp_elt_longcst (ps
, selid
);
521 write_exp_elt_longcst (ps
, val
); /* Number of args */
528 * Function: specialcmp (const char *a, const char *b)
530 * Special strcmp: treats ']' and ' ' as end-of-string.
531 * Used for qsorting lists of objc methods (either by class or selector).
535 specialcmp (const char *a
, const char *b
)
537 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
543 if (*a
&& *a
!= ' ' && *a
!= ']')
544 return 1; /* a is longer therefore greater. */
545 if (*b
&& *b
!= ' ' && *b
!= ']')
546 return -1; /* a is shorter therefore lesser. */
547 return 0; /* a and b are identical. */
551 * Function: compare_selectors (const void *, const void *)
553 * Comparison function for use with qsort. Arguments are symbols or
554 * msymbols Compares selector part of objc method name alphabetically.
558 compare_selectors (const void *a
, const void *b
)
560 const char *aname
, *bname
;
562 aname
= (*(struct symbol
**) a
)->print_name ();
563 bname
= (*(struct symbol
**) b
)->print_name ();
564 if (aname
== NULL
|| bname
== NULL
)
565 error (_("internal: compare_selectors(1)"));
567 aname
= strchr(aname
, ' ');
568 bname
= strchr(bname
, ' ');
569 if (aname
== NULL
|| bname
== NULL
)
570 error (_("internal: compare_selectors(2)"));
572 return specialcmp (aname
+1, bname
+1);
576 * Function: selectors_info (regexp, from_tty)
578 * Implements the "Info selectors" command. Takes an optional regexp
579 * arg. Lists all objective c selectors that match the regexp. Works
580 * by grepping thru all symbols for objective c methods. Output list
581 * is sorted and uniqued.
585 info_selectors_command (const char *regexp
, int from_tty
)
594 struct symbol
**sym_arr
;
598 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
601 if (*regexp
== '+' || *regexp
== '-')
602 { /* User wants only class methods or only instance methods. */
603 plusminus
= *regexp
++;
604 while (*regexp
== ' ' || *regexp
== '\t')
608 strcpy(myregexp
, ".*]");
611 /* Allow a few extra bytes because of the strcat below. */
612 if (sizeof (myregexp
) < strlen (regexp
) + 4)
613 error (_("Regexp is too long: %s"), regexp
);
614 strcpy(myregexp
, regexp
);
615 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
616 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
618 strcat(myregexp
, ".*]");
624 val
= re_comp (myregexp
);
626 error (_("Invalid regexp (%s): %s"), val
, regexp
);
629 /* First time thru is JUST to get max length and count. */
630 for (objfile
*objfile
: current_program_space
->objfiles ())
632 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
635 name
= msymbol
->natural_name ();
637 && (name
[0] == '-' || name
[0] == '+')
638 && name
[1] == '[') /* Got a method name. */
640 /* Filter for class/instance methods. */
641 if (plusminus
&& name
[0] != plusminus
)
643 /* Find selector part. */
644 name
= (char *) strchr (name
+2, ' ');
647 complaint (_("Bad method name '%s'"),
648 msymbol
->natural_name ());
651 if (regexp
== NULL
|| re_exec(++name
) != 0)
653 const char *mystart
= name
;
654 const char *myend
= strchr (mystart
, ']');
656 if (myend
&& (myend
- mystart
> maxlen
))
657 maxlen
= myend
- mystart
; /* Get longest selector. */
665 printf_filtered (_("Selectors matching \"%s\":\n\n"),
666 regexp
? regexp
: "*");
668 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
670 for (objfile
*objfile
: current_program_space
->objfiles ())
672 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
675 name
= msymbol
->natural_name ();
677 (name
[0] == '-' || name
[0] == '+') &&
678 name
[1] == '[') /* Got a method name. */
680 /* Filter for class/instance methods. */
681 if (plusminus
&& name
[0] != plusminus
)
683 /* Find selector part. */
684 name
= (char *) strchr(name
+2, ' ');
685 if (regexp
== NULL
|| re_exec(++name
) != 0)
686 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
691 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
693 /* Prevent compare on first iteration. */
695 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
700 name
= sym_arr
[ix
]->natural_name ();
701 name
= strchr (name
, ' ') + 1;
702 if (p
[0] && specialcmp(name
, p
) == 0)
703 continue; /* Seen this one already (not unique). */
705 /* Copy selector part. */
706 while (*name
&& *name
!= ']')
709 /* Print in columns. */
710 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
715 printf_filtered (_("No selectors matching \"%s\"\n"),
716 regexp
? regexp
: "*");
720 * Function: compare_classes (const void *, const void *)
722 * Comparison function for use with qsort. Arguments are symbols or
723 * msymbols Compares class part of objc method name alphabetically.
727 compare_classes (const void *a
, const void *b
)
729 const char *aname
, *bname
;
731 aname
= (*(struct symbol
**) a
)->print_name ();
732 bname
= (*(struct symbol
**) b
)->print_name ();
733 if (aname
== NULL
|| bname
== NULL
)
734 error (_("internal: compare_classes(1)"));
736 return specialcmp (aname
+1, bname
+1);
740 * Function: classes_info(regexp, from_tty)
742 * Implements the "info classes" command for objective c classes.
743 * Lists all objective c classes that match the optional regexp.
744 * Works by grepping thru the list of objective c methods. List will
745 * be sorted and uniqued (since one class may have many methods).
746 * BUGS: will not list a class that has no methods.
750 info_classes_command (const char *regexp
, int from_tty
)
759 struct symbol
**sym_arr
;
762 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
765 /* Allow a few extra bytes because of the strcat below. */
766 if (sizeof (myregexp
) < strlen (regexp
) + 4)
767 error (_("Regexp is too long: %s"), regexp
);
768 strcpy(myregexp
, regexp
);
769 if (myregexp
[strlen(myregexp
) - 1] == '$')
770 /* In the method name, the end of the class name is marked by ' '. */
771 myregexp
[strlen(myregexp
) - 1] = ' ';
773 strcat(myregexp
, ".* ");
778 val
= re_comp (myregexp
);
780 error (_("Invalid regexp (%s): %s"), val
, regexp
);
783 /* First time thru is JUST to get max length and count. */
784 for (objfile
*objfile
: current_program_space
->objfiles ())
786 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
789 name
= msymbol
->natural_name ();
791 (name
[0] == '-' || name
[0] == '+') &&
792 name
[1] == '[') /* Got a method name. */
793 if (regexp
== NULL
|| re_exec(name
+2) != 0)
795 /* Compute length of classname part. */
796 const char *mystart
= name
+ 2;
797 const char *myend
= strchr (mystart
, ' ');
799 if (myend
&& (myend
- mystart
> maxlen
))
800 maxlen
= myend
- mystart
;
807 printf_filtered (_("Classes matching \"%s\":\n\n"),
808 regexp
? regexp
: "*");
809 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
811 for (objfile
*objfile
: current_program_space
->objfiles ())
813 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
816 name
= msymbol
->natural_name ();
818 (name
[0] == '-' || name
[0] == '+') &&
819 name
[1] == '[') /* Got a method name. */
820 if (regexp
== NULL
|| re_exec(name
+2) != 0)
821 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
825 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
827 /* Prevent compare on first iteration. */
829 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
834 name
= sym_arr
[ix
]->natural_name ();
836 if (p
[0] && specialcmp(name
, p
) == 0)
837 continue; /* Seen this one already (not unique). */
839 /* Copy class part of method name. */
840 while (*name
&& *name
!= ' ')
843 /* Print in columns. */
844 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
849 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
853 parse_selector (char *method
, char **selector
)
859 char *nselector
= NULL
;
861 gdb_assert (selector
!= NULL
);
865 s1
= skip_spaces (s1
);
871 s1
= skip_spaces (s1
);
878 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
880 else if (isspace (*s2
))
882 else if ((*s2
== '\0') || (*s2
== '\''))
890 s2
= skip_spaces (s2
);
895 s2
= skip_spaces (s2
);
898 if (selector
!= NULL
)
899 *selector
= nselector
;
905 parse_method (char *method
, char *type
, char **theclass
,
906 char **category
, char **selector
)
914 char *ncategory
= NULL
;
915 char *nselector
= NULL
;
917 gdb_assert (type
!= NULL
);
918 gdb_assert (theclass
!= NULL
);
919 gdb_assert (category
!= NULL
);
920 gdb_assert (selector
!= NULL
);
924 s1
= skip_spaces (s1
);
930 s1
= skip_spaces (s1
);
932 if ((s1
[0] == '+') || (s1
[0] == '-'))
935 s1
= skip_spaces (s1
);
942 while (isalnum (*s1
) || (*s1
== '_'))
946 s2
= skip_spaces (s2
);
951 s2
= skip_spaces (s2
);
953 while (isalnum (*s2
) || (*s2
== '_'))
958 /* Truncate the class name now that we're not using the open paren. */
966 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
968 else if (isspace (*s2
))
979 s2
= skip_spaces (s2
);
985 s2
= skip_spaces (s2
);
990 if (theclass
!= NULL
)
992 if (category
!= NULL
)
993 *category
= ncategory
;
994 if (selector
!= NULL
)
995 *selector
= nselector
;
1001 find_methods (char type
, const char *theclass
, const char *category
,
1002 const char *selector
,
1003 std::vector
<const char *> *symbol_names
)
1005 const char *symname
= NULL
;
1008 char *nclass
= NULL
;
1009 char *ncategory
= NULL
;
1010 char *nselector
= NULL
;
1012 static char *tmp
= NULL
;
1013 static unsigned int tmplen
= 0;
1015 gdb_assert (symbol_names
!= NULL
);
1017 for (objfile
*objfile
: current_program_space
->objfiles ())
1019 unsigned int *objc_csym
;
1021 /* The objfile_csym variable counts the number of ObjC methods
1022 that this objfile defines. We save that count as a private
1023 objfile data. If we have already determined that this objfile
1024 provides no ObjC methods, we can skip it entirely. */
1026 unsigned int objfile_csym
= 0;
1028 objc_csym
= objc_objfile_data
.get (objfile
);
1029 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1030 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1033 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1037 /* Check the symbol name first as this can be done entirely without
1038 sending any query to the target. */
1039 symname
= msymbol
->natural_name ();
1040 if (symname
== NULL
)
1043 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1044 /* Not a method name. */
1049 /* Now that thinks are a bit sane, clean up the symname. */
1050 while ((strlen (symname
) + 1) >= tmplen
)
1052 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1053 tmp
= (char *) xrealloc (tmp
, tmplen
);
1055 strcpy (tmp
, symname
);
1057 if (parse_method (tmp
, &ntype
, &nclass
,
1058 &ncategory
, &nselector
) == NULL
)
1061 if ((type
!= '\0') && (ntype
!= type
))
1064 if ((theclass
!= NULL
)
1065 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1068 if ((category
!= NULL
) &&
1069 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1072 if ((selector
!= NULL
) &&
1073 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1076 symbol_names
->push_back (symname
);
1079 if (objc_csym
== NULL
)
1080 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1082 /* Count of ObjC methods in this objfile should be constant. */
1083 gdb_assert (*objc_csym
== objfile_csym
);
1087 /* Uniquify a vector of strings. */
1090 uniquify_strings (std::vector
<const char *> *strings
)
1092 if (strings
->empty ())
1095 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1096 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1101 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1103 * Input: a string representing a selector
1104 * a pointer to an array of symbol pointers
1105 * possibly a pointer to a symbol found by the caller.
1107 * Output: number of methods that implement that selector. Side
1108 * effects: The array of symbol pointers is filled with matching syms.
1110 * By analogy with function "find_methods" (symtab.c), builds a list
1111 * of symbols matching the ambiguous input, so that "decode_line_2"
1112 * (symtab.c) can list them and ask the user to choose one or more.
1113 * In this case the matches are objective c methods
1114 * ("implementations") matching an objective c selector.
1116 * Note that it is possible for a normal (c-style) function to have
1117 * the same name as an objective c selector. To prevent the selector
1118 * from eclipsing the function, we allow the caller (decode_line_1) to
1119 * search for such a function first, and if it finds one, pass it in
1120 * to us. We will then integrate it into the list. We also search
1121 * for one here, among the minsyms.
1123 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1124 * into two parts: debuggable (struct symbol) syms, and
1125 * non_debuggable (struct minimal_symbol) syms. The debuggable
1126 * ones will come first, before NUM_DEBUGGABLE (which will thus
1127 * be the index of the first non-debuggable one).
1131 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1134 char *theclass
= NULL
;
1135 char *category
= NULL
;
1136 char *selector
= NULL
;
1141 int selector_case
= 0;
1143 gdb_assert (symbol_names
!= NULL
);
1145 buf
= (char *) alloca (strlen (method
) + 1);
1146 strcpy (buf
, method
);
1147 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1151 strcpy (buf
, method
);
1152 tmp
= parse_selector (buf
, &selector
);
1160 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1162 /* If we hit the "selector" case, and we found some methods, then
1163 add the selector itself as a symbol, if it exists. */
1164 if (selector_case
&& !symbol_names
->empty ())
1166 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1170 symbol_names
->push_back (sym
->natural_name ());
1173 struct bound_minimal_symbol msym
1174 = lookup_minimal_symbol (selector
, 0, 0);
1176 if (msym
.minsym
!= NULL
)
1177 symbol_names
->push_back (msym
.minsym
->natural_name ());
1181 uniquify_strings (symbol_names
);
1183 return method
+ (tmp
- buf
);
1187 print_object_command (const char *args
, int from_tty
)
1189 struct value
*object
, *function
, *description
;
1190 CORE_ADDR string_addr
, object_addr
;
1194 if (!args
|| !*args
)
1196 "The 'print-object' command requires an argument (an Objective-C object)");
1199 expression_up expr
= parse_expression (args
);
1202 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1203 expr
.get (), &pc
, EVAL_NORMAL
);
1206 /* Validate the address for sanity. */
1207 object_addr
= value_as_long (object
);
1208 read_memory (object_addr
, &c
, 1);
1210 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1211 if (function
== NULL
)
1212 error (_("Unable to locate _NSPrintForDebugger in child process"));
1214 description
= call_function_by_hand (function
, NULL
, object
);
1216 string_addr
= value_as_long (description
);
1217 if (string_addr
== 0)
1218 error (_("object returns null description"));
1220 read_memory (string_addr
+ i
++, &c
, 1);
1223 { /* Read and print characters up to EOS. */
1225 printf_filtered ("%c", c
);
1226 read_memory (string_addr
+ i
++, &c
, 1);
1229 printf_filtered(_("<object returns empty description>"));
1230 printf_filtered ("\n");
1233 /* The data structure 'methcalls' is used to detect method calls (thru
1234 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1235 * and ultimately find the method being called.
1238 struct objc_methcall
{
1240 /* Return instance method to be called. */
1241 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1242 /* Start of pc range corresponding to method invocation. */
1244 /* End of pc range corresponding to method invocation. */
1248 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1249 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1250 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1251 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1253 static struct objc_methcall methcalls
[] = {
1254 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1255 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1256 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1257 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1258 { "_objc_getClass", NULL
, 0, 0},
1259 { "_objc_getMetaClass", NULL
, 0, 0}
1262 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1264 /* The following function, "find_objc_msgsend", fills in the data
1265 * structure "objc_msgs" by finding the addresses of each of the
1266 * (currently four) functions that it holds (of which objc_msgSend is
1267 * the first). This must be called each time symbols are loaded, in
1268 * case the functions have moved for some reason.
1272 find_objc_msgsend (void)
1276 for (i
= 0; i
< nmethcalls
; i
++)
1278 struct bound_minimal_symbol func
;
1280 /* Try both with and without underscore. */
1281 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1282 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1284 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1286 if (func
.minsym
== NULL
)
1288 methcalls
[i
].begin
= 0;
1289 methcalls
[i
].end
= 0;
1293 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1294 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1298 /* find_objc_msgcall (replaces pc_off_limits)
1300 * ALL that this function now does is to determine whether the input
1301 * address ("pc") is the address of one of the Objective-C message
1302 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1303 * if so, it returns the address of the method that will be called.
1305 * The old function "pc_off_limits" used to do a lot of other things
1306 * in addition, such as detecting shared library jump stubs and
1307 * returning the address of the shlib function that would be called.
1308 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1309 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1310 * dependent modules.
1314 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1320 if (f (pc
, new_pc
) == 0)
1323 catch (const gdb_exception
&ex
)
1325 exception_fprintf (gdb_stderr
, ex
,
1326 "Unable to determine target of "
1327 "Objective-C method call (ignoring):\n");
1334 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1338 find_objc_msgsend ();
1344 for (i
= 0; i
< nmethcalls
; i
++)
1345 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1347 if (methcalls
[i
].stop_at
!= NULL
)
1348 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1357 void _initialize_objc_language ();
1359 _initialize_objc_language ()
1361 add_info ("selectors", info_selectors_command
,
1362 _("All Objective-C selectors, or those matching REGEXP."));
1363 add_info ("classes", info_classes_command
,
1364 _("All Objective-C classes, or those matching REGEXP."));
1365 add_com ("print-object", class_vars
, print_object_command
,
1366 _("Ask an Objective-C object to print itself."));
1367 add_com_alias ("po", "print-object", class_vars
, 1);
1371 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1372 struct objc_method
*method
)
1374 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1376 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1377 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1378 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1381 static unsigned long
1382 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1384 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1386 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1390 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1391 unsigned long num
, struct objc_method
*method
)
1393 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1394 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1398 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1399 struct objc_object
*object
)
1401 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1403 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1407 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1408 struct objc_super
*super
)
1410 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1412 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1413 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1417 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1418 struct objc_class
*theclass
)
1420 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1422 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1423 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1424 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1425 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1426 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1427 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1429 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1430 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1431 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1432 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1436 find_implementation_from_class (struct gdbarch
*gdbarch
,
1437 CORE_ADDR theclass
, CORE_ADDR sel
)
1439 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1440 CORE_ADDR subclass
= theclass
;
1442 while (subclass
!= 0)
1445 struct objc_class class_str
;
1446 unsigned mlistnum
= 0;
1448 read_objc_class (gdbarch
, subclass
, &class_str
);
1453 unsigned long nmethods
;
1456 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1462 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1464 for (i
= 0; i
< nmethods
; i
++)
1466 struct objc_method meth_str
;
1468 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1470 if (meth_str
.name
== sel
)
1471 /* FIXME: hppa arch was doing a pointer dereference
1472 here. There needs to be a better way to do that. */
1473 return meth_str
.imp
;
1477 subclass
= class_str
.super_class
;
1484 find_implementation (struct gdbarch
*gdbarch
,
1485 CORE_ADDR object
, CORE_ADDR sel
)
1487 struct objc_object ostr
;
1491 read_objc_object (gdbarch
, object
, &ostr
);
1495 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1499 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1501 struct frame_info
*frame
= get_current_frame ();
1502 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1503 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1509 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1510 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1512 res
= find_implementation (gdbarch
, object
, sel
);
1521 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1523 struct frame_info
*frame
= get_current_frame ();
1524 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1525 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1531 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1532 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1534 res
= find_implementation (gdbarch
, object
, sel
);
1543 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1545 struct frame_info
*frame
= get_current_frame ();
1546 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1547 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1549 struct objc_super sstr
;
1555 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1556 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1558 read_objc_super (gdbarch
, super
, &sstr
);
1559 if (sstr
.theclass
== 0)
1562 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1571 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1573 struct frame_info
*frame
= get_current_frame ();
1574 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1575 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1577 struct objc_super sstr
;
1583 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1584 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1586 read_objc_super (gdbarch
, super
, &sstr
);
1587 if (sstr
.theclass
== 0)
1590 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);