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 /* Constant data representing the Objective-C language. */
324 extern const struct language_data objc_language_data
=
330 &exp_descriptor_standard
,
331 false, /* la_store_sym_names_in_linkage_form_p */
332 objc_op_print_tab
, /* Expression operators for printing */
333 1, /* C-style arrays */
334 0, /* String lower bound */
338 /* Class representing the Objective-C language. */
340 class objc_language
: public language_defn
344 : language_defn (language_objc
, objc_language_data
)
347 /* See language.h. */
349 const char *name () const override
350 { return "objective-c"; }
352 /* See language.h. */
354 const char *natural_name () const override
355 { return "Objective-C"; }
357 /* See language.h. */
359 const std::vector
<const char *> &filename_extensions () const override
361 static const std::vector
<const char *> extensions
= { ".m" };
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
;
430 /* See language.h. */
432 const char *name_of_this () const override
436 /* Single instance of the class representing the Objective-C language. */
438 static objc_language objc_language_defn
;
442 * Following functions help construct Objective-C message calls.
445 struct selname
/* For parsing Objective-C. */
447 struct selname
*next
;
452 static int msglist_len
;
453 static struct selname
*selname_chain
;
454 static char *msglist_sel
;
459 struct selname
*newobj
= XNEW (struct selname
);
461 newobj
->next
= selname_chain
;
462 newobj
->msglist_len
= msglist_len
;
463 newobj
->msglist_sel
= msglist_sel
;
465 msglist_sel
= (char *)xmalloc(1);
467 selname_chain
= newobj
;
471 add_msglist(struct stoken
*str
, int addcolon
)
477 if (str
== 0) /* Unnamed arg, or... */
479 if (addcolon
== 0) /* variable number of args. */
492 len
= plen
+ strlen(msglist_sel
) + 2;
493 s
= (char *)xmalloc(len
);
494 strcpy(s
, msglist_sel
);
509 end_msglist (struct parser_state
*ps
)
511 int val
= msglist_len
;
512 struct selname
*sel
= selname_chain
;
513 char *p
= msglist_sel
;
516 selname_chain
= sel
->next
;
517 msglist_len
= sel
->msglist_len
;
518 msglist_sel
= sel
->msglist_sel
;
519 selid
= lookup_child_selector (ps
->gdbarch (), p
);
521 error (_("Can't find selector \"%s\""), p
);
522 write_exp_elt_longcst (ps
, selid
);
524 write_exp_elt_longcst (ps
, val
); /* Number of args */
531 * Function: specialcmp (const char *a, const char *b)
533 * Special strcmp: treats ']' and ' ' as end-of-string.
534 * Used for qsorting lists of objc methods (either by class or selector).
538 specialcmp (const char *a
, const char *b
)
540 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
546 if (*a
&& *a
!= ' ' && *a
!= ']')
547 return 1; /* a is longer therefore greater. */
548 if (*b
&& *b
!= ' ' && *b
!= ']')
549 return -1; /* a is shorter therefore lesser. */
550 return 0; /* a and b are identical. */
554 * Function: compare_selectors (const void *, const void *)
556 * Comparison function for use with qsort. Arguments are symbols or
557 * msymbols Compares selector part of objc method name alphabetically.
561 compare_selectors (const void *a
, const void *b
)
563 const char *aname
, *bname
;
565 aname
= (*(struct symbol
**) a
)->print_name ();
566 bname
= (*(struct symbol
**) b
)->print_name ();
567 if (aname
== NULL
|| bname
== NULL
)
568 error (_("internal: compare_selectors(1)"));
570 aname
= strchr(aname
, ' ');
571 bname
= strchr(bname
, ' ');
572 if (aname
== NULL
|| bname
== NULL
)
573 error (_("internal: compare_selectors(2)"));
575 return specialcmp (aname
+1, bname
+1);
579 * Function: selectors_info (regexp, from_tty)
581 * Implements the "Info selectors" command. Takes an optional regexp
582 * arg. Lists all objective c selectors that match the regexp. Works
583 * by grepping thru all symbols for objective c methods. Output list
584 * is sorted and uniqued.
588 info_selectors_command (const char *regexp
, int from_tty
)
597 struct symbol
**sym_arr
;
601 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
604 if (*regexp
== '+' || *regexp
== '-')
605 { /* User wants only class methods or only instance methods. */
606 plusminus
= *regexp
++;
607 while (*regexp
== ' ' || *regexp
== '\t')
611 strcpy(myregexp
, ".*]");
614 /* Allow a few extra bytes because of the strcat below. */
615 if (sizeof (myregexp
) < strlen (regexp
) + 4)
616 error (_("Regexp is too long: %s"), regexp
);
617 strcpy(myregexp
, regexp
);
618 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
619 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
621 strcat(myregexp
, ".*]");
627 val
= re_comp (myregexp
);
629 error (_("Invalid regexp (%s): %s"), val
, regexp
);
632 /* First time thru is JUST to get max length and count. */
633 for (objfile
*objfile
: current_program_space
->objfiles ())
635 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
638 name
= msymbol
->natural_name ();
640 && (name
[0] == '-' || name
[0] == '+')
641 && name
[1] == '[') /* Got a method name. */
643 /* Filter for class/instance methods. */
644 if (plusminus
&& name
[0] != plusminus
)
646 /* Find selector part. */
647 name
= (char *) strchr (name
+2, ' ');
650 complaint (_("Bad method name '%s'"),
651 msymbol
->natural_name ());
654 if (regexp
== NULL
|| re_exec(++name
) != 0)
656 const char *mystart
= name
;
657 const char *myend
= strchr (mystart
, ']');
659 if (myend
&& (myend
- mystart
> maxlen
))
660 maxlen
= myend
- mystart
; /* Get longest selector. */
668 printf_filtered (_("Selectors matching \"%s\":\n\n"),
669 regexp
? regexp
: "*");
671 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
673 for (objfile
*objfile
: current_program_space
->objfiles ())
675 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
678 name
= msymbol
->natural_name ();
680 (name
[0] == '-' || name
[0] == '+') &&
681 name
[1] == '[') /* Got a method name. */
683 /* Filter for class/instance methods. */
684 if (plusminus
&& name
[0] != plusminus
)
686 /* Find selector part. */
687 name
= (char *) strchr(name
+2, ' ');
688 if (regexp
== NULL
|| re_exec(++name
) != 0)
689 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
694 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
696 /* Prevent compare on first iteration. */
698 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
703 name
= sym_arr
[ix
]->natural_name ();
704 name
= strchr (name
, ' ') + 1;
705 if (p
[0] && specialcmp(name
, p
) == 0)
706 continue; /* Seen this one already (not unique). */
708 /* Copy selector part. */
709 while (*name
&& *name
!= ']')
712 /* Print in columns. */
713 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
718 printf_filtered (_("No selectors matching \"%s\"\n"),
719 regexp
? regexp
: "*");
723 * Function: compare_classes (const void *, const void *)
725 * Comparison function for use with qsort. Arguments are symbols or
726 * msymbols Compares class part of objc method name alphabetically.
730 compare_classes (const void *a
, const void *b
)
732 const char *aname
, *bname
;
734 aname
= (*(struct symbol
**) a
)->print_name ();
735 bname
= (*(struct symbol
**) b
)->print_name ();
736 if (aname
== NULL
|| bname
== NULL
)
737 error (_("internal: compare_classes(1)"));
739 return specialcmp (aname
+1, bname
+1);
743 * Function: classes_info(regexp, from_tty)
745 * Implements the "info classes" command for objective c classes.
746 * Lists all objective c classes that match the optional regexp.
747 * Works by grepping thru the list of objective c methods. List will
748 * be sorted and uniqued (since one class may have many methods).
749 * BUGS: will not list a class that has no methods.
753 info_classes_command (const char *regexp
, int from_tty
)
762 struct symbol
**sym_arr
;
765 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
768 /* Allow a few extra bytes because of the strcat below. */
769 if (sizeof (myregexp
) < strlen (regexp
) + 4)
770 error (_("Regexp is too long: %s"), regexp
);
771 strcpy(myregexp
, regexp
);
772 if (myregexp
[strlen(myregexp
) - 1] == '$')
773 /* In the method name, the end of the class name is marked by ' '. */
774 myregexp
[strlen(myregexp
) - 1] = ' ';
776 strcat(myregexp
, ".* ");
781 val
= re_comp (myregexp
);
783 error (_("Invalid regexp (%s): %s"), val
, regexp
);
786 /* First time thru is JUST to get max length and count. */
787 for (objfile
*objfile
: current_program_space
->objfiles ())
789 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
792 name
= msymbol
->natural_name ();
794 (name
[0] == '-' || name
[0] == '+') &&
795 name
[1] == '[') /* Got a method name. */
796 if (regexp
== NULL
|| re_exec(name
+2) != 0)
798 /* Compute length of classname part. */
799 const char *mystart
= name
+ 2;
800 const char *myend
= strchr (mystart
, ' ');
802 if (myend
&& (myend
- mystart
> maxlen
))
803 maxlen
= myend
- mystart
;
810 printf_filtered (_("Classes matching \"%s\":\n\n"),
811 regexp
? regexp
: "*");
812 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
814 for (objfile
*objfile
: current_program_space
->objfiles ())
816 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
819 name
= msymbol
->natural_name ();
821 (name
[0] == '-' || name
[0] == '+') &&
822 name
[1] == '[') /* Got a method name. */
823 if (regexp
== NULL
|| re_exec(name
+2) != 0)
824 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
828 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
830 /* Prevent compare on first iteration. */
832 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
837 name
= sym_arr
[ix
]->natural_name ();
839 if (p
[0] && specialcmp(name
, p
) == 0)
840 continue; /* Seen this one already (not unique). */
842 /* Copy class part of method name. */
843 while (*name
&& *name
!= ' ')
846 /* Print in columns. */
847 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
852 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
856 parse_selector (char *method
, char **selector
)
862 char *nselector
= NULL
;
864 gdb_assert (selector
!= NULL
);
868 s1
= skip_spaces (s1
);
874 s1
= skip_spaces (s1
);
881 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
883 else if (isspace (*s2
))
885 else if ((*s2
== '\0') || (*s2
== '\''))
893 s2
= skip_spaces (s2
);
898 s2
= skip_spaces (s2
);
901 if (selector
!= NULL
)
902 *selector
= nselector
;
908 parse_method (char *method
, char *type
, char **theclass
,
909 char **category
, char **selector
)
917 char *ncategory
= NULL
;
918 char *nselector
= NULL
;
920 gdb_assert (type
!= NULL
);
921 gdb_assert (theclass
!= NULL
);
922 gdb_assert (category
!= NULL
);
923 gdb_assert (selector
!= NULL
);
927 s1
= skip_spaces (s1
);
933 s1
= skip_spaces (s1
);
935 if ((s1
[0] == '+') || (s1
[0] == '-'))
938 s1
= skip_spaces (s1
);
945 while (isalnum (*s1
) || (*s1
== '_'))
949 s2
= skip_spaces (s2
);
954 s2
= skip_spaces (s2
);
956 while (isalnum (*s2
) || (*s2
== '_'))
961 /* Truncate the class name now that we're not using the open paren. */
969 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
971 else if (isspace (*s2
))
982 s2
= skip_spaces (s2
);
988 s2
= skip_spaces (s2
);
993 if (theclass
!= NULL
)
995 if (category
!= NULL
)
996 *category
= ncategory
;
997 if (selector
!= NULL
)
998 *selector
= nselector
;
1004 find_methods (char type
, const char *theclass
, const char *category
,
1005 const char *selector
,
1006 std::vector
<const char *> *symbol_names
)
1008 const char *symname
= NULL
;
1011 char *nclass
= NULL
;
1012 char *ncategory
= NULL
;
1013 char *nselector
= NULL
;
1015 static char *tmp
= NULL
;
1016 static unsigned int tmplen
= 0;
1018 gdb_assert (symbol_names
!= NULL
);
1020 for (objfile
*objfile
: current_program_space
->objfiles ())
1022 unsigned int *objc_csym
;
1024 /* The objfile_csym variable counts the number of ObjC methods
1025 that this objfile defines. We save that count as a private
1026 objfile data. If we have already determined that this objfile
1027 provides no ObjC methods, we can skip it entirely. */
1029 unsigned int objfile_csym
= 0;
1031 objc_csym
= objc_objfile_data
.get (objfile
);
1032 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1033 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1036 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1040 /* Check the symbol name first as this can be done entirely without
1041 sending any query to the target. */
1042 symname
= msymbol
->natural_name ();
1043 if (symname
== NULL
)
1046 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1047 /* Not a method name. */
1052 /* Now that thinks are a bit sane, clean up the symname. */
1053 while ((strlen (symname
) + 1) >= tmplen
)
1055 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1056 tmp
= (char *) xrealloc (tmp
, tmplen
);
1058 strcpy (tmp
, symname
);
1060 if (parse_method (tmp
, &ntype
, &nclass
,
1061 &ncategory
, &nselector
) == NULL
)
1064 if ((type
!= '\0') && (ntype
!= type
))
1067 if ((theclass
!= NULL
)
1068 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1071 if ((category
!= NULL
) &&
1072 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1075 if ((selector
!= NULL
) &&
1076 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1079 symbol_names
->push_back (symname
);
1082 if (objc_csym
== NULL
)
1083 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1085 /* Count of ObjC methods in this objfile should be constant. */
1086 gdb_assert (*objc_csym
== objfile_csym
);
1090 /* Uniquify a vector of strings. */
1093 uniquify_strings (std::vector
<const char *> *strings
)
1095 if (strings
->empty ())
1098 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1099 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1104 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1106 * Input: a string representing a selector
1107 * a pointer to an array of symbol pointers
1108 * possibly a pointer to a symbol found by the caller.
1110 * Output: number of methods that implement that selector. Side
1111 * effects: The array of symbol pointers is filled with matching syms.
1113 * By analogy with function "find_methods" (symtab.c), builds a list
1114 * of symbols matching the ambiguous input, so that "decode_line_2"
1115 * (symtab.c) can list them and ask the user to choose one or more.
1116 * In this case the matches are objective c methods
1117 * ("implementations") matching an objective c selector.
1119 * Note that it is possible for a normal (c-style) function to have
1120 * the same name as an objective c selector. To prevent the selector
1121 * from eclipsing the function, we allow the caller (decode_line_1) to
1122 * search for such a function first, and if it finds one, pass it in
1123 * to us. We will then integrate it into the list. We also search
1124 * for one here, among the minsyms.
1126 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1127 * into two parts: debuggable (struct symbol) syms, and
1128 * non_debuggable (struct minimal_symbol) syms. The debuggable
1129 * ones will come first, before NUM_DEBUGGABLE (which will thus
1130 * be the index of the first non-debuggable one).
1134 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1137 char *theclass
= NULL
;
1138 char *category
= NULL
;
1139 char *selector
= NULL
;
1144 int selector_case
= 0;
1146 gdb_assert (symbol_names
!= NULL
);
1148 buf
= (char *) alloca (strlen (method
) + 1);
1149 strcpy (buf
, method
);
1150 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1154 strcpy (buf
, method
);
1155 tmp
= parse_selector (buf
, &selector
);
1163 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1165 /* If we hit the "selector" case, and we found some methods, then
1166 add the selector itself as a symbol, if it exists. */
1167 if (selector_case
&& !symbol_names
->empty ())
1169 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1173 symbol_names
->push_back (sym
->natural_name ());
1176 struct bound_minimal_symbol msym
1177 = lookup_minimal_symbol (selector
, 0, 0);
1179 if (msym
.minsym
!= NULL
)
1180 symbol_names
->push_back (msym
.minsym
->natural_name ());
1184 uniquify_strings (symbol_names
);
1186 return method
+ (tmp
- buf
);
1190 print_object_command (const char *args
, int from_tty
)
1192 struct value
*object
, *function
, *description
;
1193 CORE_ADDR string_addr
, object_addr
;
1197 if (!args
|| !*args
)
1199 "The 'print-object' command requires an argument (an Objective-C object)");
1202 expression_up expr
= parse_expression (args
);
1205 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1206 expr
.get (), &pc
, EVAL_NORMAL
);
1209 /* Validate the address for sanity. */
1210 object_addr
= value_as_long (object
);
1211 read_memory (object_addr
, &c
, 1);
1213 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1214 if (function
== NULL
)
1215 error (_("Unable to locate _NSPrintForDebugger in child process"));
1217 description
= call_function_by_hand (function
, NULL
, object
);
1219 string_addr
= value_as_long (description
);
1220 if (string_addr
== 0)
1221 error (_("object returns null description"));
1223 read_memory (string_addr
+ i
++, &c
, 1);
1226 { /* Read and print characters up to EOS. */
1228 printf_filtered ("%c", c
);
1229 read_memory (string_addr
+ i
++, &c
, 1);
1232 printf_filtered(_("<object returns empty description>"));
1233 printf_filtered ("\n");
1236 /* The data structure 'methcalls' is used to detect method calls (thru
1237 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1238 * and ultimately find the method being called.
1241 struct objc_methcall
{
1243 /* Return instance method to be called. */
1244 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1245 /* Start of pc range corresponding to method invocation. */
1247 /* End of pc range corresponding to method invocation. */
1251 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1252 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1253 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1254 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1256 static struct objc_methcall methcalls
[] = {
1257 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1258 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1259 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1260 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1261 { "_objc_getClass", NULL
, 0, 0},
1262 { "_objc_getMetaClass", NULL
, 0, 0}
1265 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1267 /* The following function, "find_objc_msgsend", fills in the data
1268 * structure "objc_msgs" by finding the addresses of each of the
1269 * (currently four) functions that it holds (of which objc_msgSend is
1270 * the first). This must be called each time symbols are loaded, in
1271 * case the functions have moved for some reason.
1275 find_objc_msgsend (void)
1279 for (i
= 0; i
< nmethcalls
; i
++)
1281 struct bound_minimal_symbol func
;
1283 /* Try both with and without underscore. */
1284 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1285 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1287 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1289 if (func
.minsym
== NULL
)
1291 methcalls
[i
].begin
= 0;
1292 methcalls
[i
].end
= 0;
1296 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1297 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1301 /* find_objc_msgcall (replaces pc_off_limits)
1303 * ALL that this function now does is to determine whether the input
1304 * address ("pc") is the address of one of the Objective-C message
1305 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1306 * if so, it returns the address of the method that will be called.
1308 * The old function "pc_off_limits" used to do a lot of other things
1309 * in addition, such as detecting shared library jump stubs and
1310 * returning the address of the shlib function that would be called.
1311 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1312 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1313 * dependent modules.
1317 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1323 if (f (pc
, new_pc
) == 0)
1326 catch (const gdb_exception
&ex
)
1328 exception_fprintf (gdb_stderr
, ex
,
1329 "Unable to determine target of "
1330 "Objective-C method call (ignoring):\n");
1337 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1341 find_objc_msgsend ();
1347 for (i
= 0; i
< nmethcalls
; i
++)
1348 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1350 if (methcalls
[i
].stop_at
!= NULL
)
1351 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1360 void _initialize_objc_language ();
1362 _initialize_objc_language ()
1364 add_info ("selectors", info_selectors_command
,
1365 _("All Objective-C selectors, or those matching REGEXP."));
1366 add_info ("classes", info_classes_command
,
1367 _("All Objective-C classes, or those matching REGEXP."));
1368 add_com ("print-object", class_vars
, print_object_command
,
1369 _("Ask an Objective-C object to print itself."));
1370 add_com_alias ("po", "print-object", class_vars
, 1);
1374 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1375 struct objc_method
*method
)
1377 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1379 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1380 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1381 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1384 static unsigned long
1385 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1387 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1389 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1393 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1394 unsigned long num
, struct objc_method
*method
)
1396 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1397 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1401 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1402 struct objc_object
*object
)
1404 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1406 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1410 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1411 struct objc_super
*super
)
1413 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1415 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1416 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1420 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1421 struct objc_class
*theclass
)
1423 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1425 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1426 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1427 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1428 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1429 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1430 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1432 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1433 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1434 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1435 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1439 find_implementation_from_class (struct gdbarch
*gdbarch
,
1440 CORE_ADDR theclass
, CORE_ADDR sel
)
1442 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1443 CORE_ADDR subclass
= theclass
;
1445 while (subclass
!= 0)
1448 struct objc_class class_str
;
1449 unsigned mlistnum
= 0;
1451 read_objc_class (gdbarch
, subclass
, &class_str
);
1456 unsigned long nmethods
;
1459 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1465 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1467 for (i
= 0; i
< nmethods
; i
++)
1469 struct objc_method meth_str
;
1471 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1473 if (meth_str
.name
== sel
)
1474 /* FIXME: hppa arch was doing a pointer dereference
1475 here. There needs to be a better way to do that. */
1476 return meth_str
.imp
;
1480 subclass
= class_str
.super_class
;
1487 find_implementation (struct gdbarch
*gdbarch
,
1488 CORE_ADDR object
, CORE_ADDR sel
)
1490 struct objc_object ostr
;
1494 read_objc_object (gdbarch
, object
, &ostr
);
1498 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1502 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1504 struct frame_info
*frame
= get_current_frame ();
1505 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1506 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1512 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1513 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1515 res
= find_implementation (gdbarch
, object
, sel
);
1524 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1526 struct frame_info
*frame
= get_current_frame ();
1527 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1528 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1534 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1535 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1537 res
= find_implementation (gdbarch
, object
, sel
);
1546 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1548 struct frame_info
*frame
= get_current_frame ();
1549 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1550 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1552 struct objc_super sstr
;
1558 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1559 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1561 read_objc_super (gdbarch
, super
, &sstr
);
1562 if (sstr
.theclass
== 0)
1565 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1574 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1576 struct frame_info
*frame
= get_current_frame ();
1577 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1578 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1580 struct objc_super sstr
;
1586 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1587 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1589 read_objc_super (gdbarch
, super
, &sstr
);
1590 if (sstr
.theclass
== 0)
1593 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);