1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2020 Free Software Foundation, Inc.
5 Contributed by Apple Computer, Inc.
6 Written by Michael Snyder.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
27 #include "parser-defs.h"
31 #include "objc-lang.h"
32 #include "complaints.h"
36 #include "target.h" /* for target_has_execution */
40 #include "gdb_regex.h"
45 #include "cli/cli-utils.h"
56 CORE_ADDR super_class
;
78 static const struct objfile_key
<unsigned int> objc_objfile_data
;
80 /* Lookup a structure type named "struct NAME", visible in lexical
81 block BLOCK. If NOERR is nonzero, return zero if NAME is not
85 lookup_struct_typedef (const char *name
, const struct block
*block
, int noerr
)
89 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
96 error (_("No struct type named %s."), name
);
98 if (SYMBOL_TYPE (sym
)->code () != TYPE_CODE_STRUCT
)
103 error (_("This context has class, union or enum %s, not a struct."),
110 lookup_objc_class (struct gdbarch
*gdbarch
, const char *classname
)
112 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
113 struct value
* function
, *classval
;
115 if (! target_has_execution
)
117 /* Can't call into inferior to lookup class. */
121 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0).minsym
)
122 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
123 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym
)
124 function
= find_function_in_inferior("objc_lookup_class", NULL
);
127 complaint (_("no way to lookup Objective-C classes"));
131 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
132 classval
= value_coerce_array (classval
);
133 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
139 lookup_child_selector (struct gdbarch
*gdbarch
, const char *selname
)
141 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
142 struct value
* function
, *selstring
;
144 if (! target_has_execution
)
146 /* Can't call into inferior to lookup selector. */
150 if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym
)
151 function
= find_function_in_inferior("sel_getUid", NULL
);
152 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym
)
153 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
156 complaint (_("no way to lookup Objective-C selectors"));
160 selstring
= value_coerce_array (value_string (selname
,
161 strlen (selname
) + 1,
163 return value_as_long (call_function_by_hand (function
, NULL
, selstring
));
167 value_nsstring (struct gdbarch
*gdbarch
, char *ptr
, int len
)
169 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
170 struct value
*stringValue
[3];
171 struct value
*function
, *nsstringValue
;
175 if (!target_has_execution
)
176 return 0; /* Can't call into inferior to create NSString. */
178 stringValue
[2] = value_string(ptr
, len
, char_type
);
179 stringValue
[2] = value_coerce_array(stringValue
[2]);
180 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
181 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym
)
183 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
184 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
186 else if (lookup_minimal_symbol("istr", 0, 0).minsym
)
188 function
= find_function_in_inferior("istr", NULL
);
189 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
[2]);
191 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym
)
194 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
195 type
= builtin_type (gdbarch
)->builtin_long
;
197 stringValue
[0] = value_from_longest
198 (type
, lookup_objc_class (gdbarch
, "NSString"));
199 stringValue
[1] = value_from_longest
200 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
201 nsstringValue
= call_function_by_hand(function
, NULL
, stringValue
);
204 error (_("NSString: internal error -- no way to create new NSString"));
206 sym
= lookup_struct_typedef("NSString", 0, 1);
208 sym
= lookup_struct_typedef("NXString", 0, 1);
210 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
212 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
214 deprecated_set_value_type (nsstringValue
, type
);
215 return nsstringValue
;
218 /* Objective-C name demangling. */
221 objc_demangle (const char *mangled
, int options
)
223 char *demangled
, *cp
;
225 if (mangled
[0] == '_' &&
226 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
229 cp
= demangled
= (char *) xmalloc (strlen (mangled
) + 2);
231 if (mangled
[1] == 'i')
232 *cp
++ = '-'; /* for instance method */
234 *cp
++ = '+'; /* for class method */
236 *cp
++ = '['; /* opening left brace */
237 strcpy(cp
, mangled
+3); /* Tack on the rest of the mangled name. */
239 while (*cp
&& *cp
== '_')
240 cp
++; /* Skip any initial underbars in class
243 cp
= strchr(cp
, '_');
244 if (!cp
) /* Find first non-initial underbar. */
246 xfree(demangled
); /* not mangled name */
249 if (cp
[1] == '_') /* Easy case: no category name. */
251 *cp
++ = ' '; /* Replace two '_' with one ' '. */
252 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
256 *cp
++ = '('; /* Less easy case: category name. */
257 cp
= strchr(cp
, '_');
260 xfree(demangled
); /* not mangled name */
264 *cp
++ = ' '; /* Overwriting 1st char of method name... */
265 strcpy(cp
, mangled
+ (cp
- demangled
)); /* Get it back. */
268 while (*cp
&& *cp
== '_')
269 cp
++; /* Skip any initial underbars in
274 *cp
= ':'; /* Replace remaining '_' with ':'. */
276 *cp
++ = ']'; /* closing right brace */
277 *cp
++ = 0; /* string terminator */
281 return NULL
; /* Not an objc mangled name. */
285 /* Table mapping opcodes into strings for printing operators
286 and precedences of the operators. */
288 static const struct op_print objc_op_print_tab
[] =
290 {",", BINOP_COMMA
, PREC_COMMA
, 0},
291 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
292 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
293 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
294 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
295 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
296 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
297 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
298 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
299 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
300 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
301 {">", BINOP_GTR
, PREC_ORDER
, 0},
302 {"<", BINOP_LESS
, PREC_ORDER
, 0},
303 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
304 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
305 {"+", BINOP_ADD
, PREC_ADD
, 0},
306 {"-", BINOP_SUB
, PREC_ADD
, 0},
307 {"*", BINOP_MUL
, PREC_MUL
, 0},
308 {"/", BINOP_DIV
, PREC_MUL
, 0},
309 {"%", BINOP_REM
, PREC_MUL
, 0},
310 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
311 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
312 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
313 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
314 {"*", UNOP_IND
, PREC_PREFIX
, 0},
315 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
316 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
317 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
318 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
319 {NULL
, OP_NULL
, PREC_NULL
, 0}
322 static const char *objc_extensions
[] =
327 /* Constant data representing the Objective-C language. */
329 extern const struct language_data objc_language_data
=
331 "objective-c", /* Language name */
339 &exp_descriptor_standard
,
340 c_printchar
, /* Print a character constant */
341 c_printstr
, /* Function to print string constant */
343 c_print_typedef
, /* Print a typedef using appropriate syntax */
344 "self", /* name_of_this */
345 false, /* la_store_sym_names_in_linkage_form_p */
346 objc_op_print_tab
, /* Expression operators for printing */
347 1, /* C-style arrays */
348 0, /* String lower bound */
351 "{...}" /* la_struct_too_deep_ellipsis */
354 /* Class representing the Objective-C language. */
356 class objc_language
: public language_defn
360 : language_defn (language_objc
, objc_language_data
)
363 /* See language.h. */
364 void language_arch_info (struct gdbarch
*gdbarch
,
365 struct language_arch_info
*lai
) const override
367 c_language_arch_info (gdbarch
, lai
);
370 /* See language.h. */
371 bool sniff_from_mangled_name (const char *mangled
,
372 char **demangled
) const override
374 *demangled
= objc_demangle (mangled
, 0);
375 return *demangled
!= NULL
;
378 /* See language.h. */
380 char *demangle (const char *mangled
, int options
) const override
382 return objc_demangle (mangled
, options
);
385 /* See language.h. */
387 void print_type (struct type
*type
, const char *varstring
,
388 struct ui_file
*stream
, int show
, int level
,
389 const struct type_print_options
*flags
) const override
391 c_print_type (type
, varstring
, stream
, show
, level
, flags
);
394 /* See language.h. */
396 CORE_ADDR
skip_trampoline (struct frame_info
*frame
,
397 CORE_ADDR stop_pc
) const override
399 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
400 CORE_ADDR real_stop_pc
;
401 CORE_ADDR method_stop_pc
;
403 /* Determine if we are currently in the Objective-C dispatch function.
404 If so, get the address of the method function that the dispatcher
405 would call and use that as the function to step into instead. Also
406 skip over the trampoline for the function (if any). This is better
407 for the user since they are only interested in stepping into the
408 method function anyway. */
410 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
412 if (real_stop_pc
!= 0)
413 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
415 find_objc_msgcall (stop_pc
, &method_stop_pc
);
419 real_stop_pc
= gdbarch_skip_trampoline_code
420 (gdbarch
, frame
, method_stop_pc
);
421 if (real_stop_pc
== 0)
422 real_stop_pc
= method_stop_pc
;
429 /* Single instance of the class representing the Objective-C language. */
431 static objc_language objc_language_defn
;
435 * Following functions help construct Objective-C message calls.
438 struct selname
/* For parsing Objective-C. */
440 struct selname
*next
;
445 static int msglist_len
;
446 static struct selname
*selname_chain
;
447 static char *msglist_sel
;
452 struct selname
*newobj
= XNEW (struct selname
);
454 newobj
->next
= selname_chain
;
455 newobj
->msglist_len
= msglist_len
;
456 newobj
->msglist_sel
= msglist_sel
;
458 msglist_sel
= (char *)xmalloc(1);
460 selname_chain
= newobj
;
464 add_msglist(struct stoken
*str
, int addcolon
)
470 if (str
== 0) /* Unnamed arg, or... */
472 if (addcolon
== 0) /* variable number of args. */
485 len
= plen
+ strlen(msglist_sel
) + 2;
486 s
= (char *)xmalloc(len
);
487 strcpy(s
, msglist_sel
);
502 end_msglist (struct parser_state
*ps
)
504 int val
= msglist_len
;
505 struct selname
*sel
= selname_chain
;
506 char *p
= msglist_sel
;
509 selname_chain
= sel
->next
;
510 msglist_len
= sel
->msglist_len
;
511 msglist_sel
= sel
->msglist_sel
;
512 selid
= lookup_child_selector (ps
->gdbarch (), p
);
514 error (_("Can't find selector \"%s\""), p
);
515 write_exp_elt_longcst (ps
, selid
);
517 write_exp_elt_longcst (ps
, val
); /* Number of args */
524 * Function: specialcmp (const char *a, const char *b)
526 * Special strcmp: treats ']' and ' ' as end-of-string.
527 * Used for qsorting lists of objc methods (either by class or selector).
531 specialcmp (const char *a
, const char *b
)
533 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
539 if (*a
&& *a
!= ' ' && *a
!= ']')
540 return 1; /* a is longer therefore greater. */
541 if (*b
&& *b
!= ' ' && *b
!= ']')
542 return -1; /* a is shorter therefore lesser. */
543 return 0; /* a and b are identical. */
547 * Function: compare_selectors (const void *, const void *)
549 * Comparison function for use with qsort. Arguments are symbols or
550 * msymbols Compares selector part of objc method name alphabetically.
554 compare_selectors (const void *a
, const void *b
)
556 const char *aname
, *bname
;
558 aname
= (*(struct symbol
**) a
)->print_name ();
559 bname
= (*(struct symbol
**) b
)->print_name ();
560 if (aname
== NULL
|| bname
== NULL
)
561 error (_("internal: compare_selectors(1)"));
563 aname
= strchr(aname
, ' ');
564 bname
= strchr(bname
, ' ');
565 if (aname
== NULL
|| bname
== NULL
)
566 error (_("internal: compare_selectors(2)"));
568 return specialcmp (aname
+1, bname
+1);
572 * Function: selectors_info (regexp, from_tty)
574 * Implements the "Info selectors" command. Takes an optional regexp
575 * arg. Lists all objective c selectors that match the regexp. Works
576 * by grepping thru all symbols for objective c methods. Output list
577 * is sorted and uniqued.
581 info_selectors_command (const char *regexp
, int from_tty
)
590 struct symbol
**sym_arr
;
594 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
597 if (*regexp
== '+' || *regexp
== '-')
598 { /* User wants only class methods or only instance methods. */
599 plusminus
= *regexp
++;
600 while (*regexp
== ' ' || *regexp
== '\t')
604 strcpy(myregexp
, ".*]");
607 /* Allow a few extra bytes because of the strcat below. */
608 if (sizeof (myregexp
) < strlen (regexp
) + 4)
609 error (_("Regexp is too long: %s"), regexp
);
610 strcpy(myregexp
, regexp
);
611 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
612 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
614 strcat(myregexp
, ".*]");
620 val
= re_comp (myregexp
);
622 error (_("Invalid regexp (%s): %s"), val
, regexp
);
625 /* First time thru is JUST to get max length and count. */
626 for (objfile
*objfile
: current_program_space
->objfiles ())
628 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
631 name
= msymbol
->natural_name ();
633 && (name
[0] == '-' || name
[0] == '+')
634 && name
[1] == '[') /* Got a method name. */
636 /* Filter for class/instance methods. */
637 if (plusminus
&& name
[0] != plusminus
)
639 /* Find selector part. */
640 name
= (char *) strchr (name
+2, ' ');
643 complaint (_("Bad method name '%s'"),
644 msymbol
->natural_name ());
647 if (regexp
== NULL
|| re_exec(++name
) != 0)
649 const char *mystart
= name
;
650 const char *myend
= strchr (mystart
, ']');
652 if (myend
&& (myend
- mystart
> maxlen
))
653 maxlen
= myend
- mystart
; /* Get longest selector. */
661 printf_filtered (_("Selectors matching \"%s\":\n\n"),
662 regexp
? regexp
: "*");
664 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
666 for (objfile
*objfile
: current_program_space
->objfiles ())
668 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
671 name
= msymbol
->natural_name ();
673 (name
[0] == '-' || name
[0] == '+') &&
674 name
[1] == '[') /* Got a method name. */
676 /* Filter for class/instance methods. */
677 if (plusminus
&& name
[0] != plusminus
)
679 /* Find selector part. */
680 name
= (char *) strchr(name
+2, ' ');
681 if (regexp
== NULL
|| re_exec(++name
) != 0)
682 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
687 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
689 /* Prevent compare on first iteration. */
691 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
696 name
= sym_arr
[ix
]->natural_name ();
697 name
= strchr (name
, ' ') + 1;
698 if (p
[0] && specialcmp(name
, p
) == 0)
699 continue; /* Seen this one already (not unique). */
701 /* Copy selector part. */
702 while (*name
&& *name
!= ']')
705 /* Print in columns. */
706 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
711 printf_filtered (_("No selectors matching \"%s\"\n"),
712 regexp
? regexp
: "*");
716 * Function: compare_classes (const void *, const void *)
718 * Comparison function for use with qsort. Arguments are symbols or
719 * msymbols Compares class part of objc method name alphabetically.
723 compare_classes (const void *a
, const void *b
)
725 const char *aname
, *bname
;
727 aname
= (*(struct symbol
**) a
)->print_name ();
728 bname
= (*(struct symbol
**) b
)->print_name ();
729 if (aname
== NULL
|| bname
== NULL
)
730 error (_("internal: compare_classes(1)"));
732 return specialcmp (aname
+1, bname
+1);
736 * Function: classes_info(regexp, from_tty)
738 * Implements the "info classes" command for objective c classes.
739 * Lists all objective c classes that match the optional regexp.
740 * Works by grepping thru the list of objective c methods. List will
741 * be sorted and uniqued (since one class may have many methods).
742 * BUGS: will not list a class that has no methods.
746 info_classes_command (const char *regexp
, int from_tty
)
755 struct symbol
**sym_arr
;
758 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
761 /* Allow a few extra bytes because of the strcat below. */
762 if (sizeof (myregexp
) < strlen (regexp
) + 4)
763 error (_("Regexp is too long: %s"), regexp
);
764 strcpy(myregexp
, regexp
);
765 if (myregexp
[strlen(myregexp
) - 1] == '$')
766 /* In the method name, the end of the class name is marked by ' '. */
767 myregexp
[strlen(myregexp
) - 1] = ' ';
769 strcat(myregexp
, ".* ");
774 val
= re_comp (myregexp
);
776 error (_("Invalid regexp (%s): %s"), val
, regexp
);
779 /* First time thru is JUST to get max length and count. */
780 for (objfile
*objfile
: current_program_space
->objfiles ())
782 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
785 name
= msymbol
->natural_name ();
787 (name
[0] == '-' || name
[0] == '+') &&
788 name
[1] == '[') /* Got a method name. */
789 if (regexp
== NULL
|| re_exec(name
+2) != 0)
791 /* Compute length of classname part. */
792 const char *mystart
= name
+ 2;
793 const char *myend
= strchr (mystart
, ' ');
795 if (myend
&& (myend
- mystart
> maxlen
))
796 maxlen
= myend
- mystart
;
803 printf_filtered (_("Classes matching \"%s\":\n\n"),
804 regexp
? regexp
: "*");
805 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
807 for (objfile
*objfile
: current_program_space
->objfiles ())
809 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
812 name
= msymbol
->natural_name ();
814 (name
[0] == '-' || name
[0] == '+') &&
815 name
[1] == '[') /* Got a method name. */
816 if (regexp
== NULL
|| re_exec(name
+2) != 0)
817 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
821 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
823 /* Prevent compare on first iteration. */
825 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
830 name
= sym_arr
[ix
]->natural_name ();
832 if (p
[0] && specialcmp(name
, p
) == 0)
833 continue; /* Seen this one already (not unique). */
835 /* Copy class part of method name. */
836 while (*name
&& *name
!= ' ')
839 /* Print in columns. */
840 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
845 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
849 parse_selector (char *method
, char **selector
)
855 char *nselector
= NULL
;
857 gdb_assert (selector
!= NULL
);
861 s1
= skip_spaces (s1
);
867 s1
= skip_spaces (s1
);
874 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
876 else if (isspace (*s2
))
878 else if ((*s2
== '\0') || (*s2
== '\''))
886 s2
= skip_spaces (s2
);
891 s2
= skip_spaces (s2
);
894 if (selector
!= NULL
)
895 *selector
= nselector
;
901 parse_method (char *method
, char *type
, char **theclass
,
902 char **category
, char **selector
)
910 char *ncategory
= NULL
;
911 char *nselector
= NULL
;
913 gdb_assert (type
!= NULL
);
914 gdb_assert (theclass
!= NULL
);
915 gdb_assert (category
!= NULL
);
916 gdb_assert (selector
!= NULL
);
920 s1
= skip_spaces (s1
);
926 s1
= skip_spaces (s1
);
928 if ((s1
[0] == '+') || (s1
[0] == '-'))
931 s1
= skip_spaces (s1
);
938 while (isalnum (*s1
) || (*s1
== '_'))
942 s2
= skip_spaces (s2
);
947 s2
= skip_spaces (s2
);
949 while (isalnum (*s2
) || (*s2
== '_'))
954 /* Truncate the class name now that we're not using the open paren. */
962 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
964 else if (isspace (*s2
))
975 s2
= skip_spaces (s2
);
981 s2
= skip_spaces (s2
);
986 if (theclass
!= NULL
)
988 if (category
!= NULL
)
989 *category
= ncategory
;
990 if (selector
!= NULL
)
991 *selector
= nselector
;
997 find_methods (char type
, const char *theclass
, const char *category
,
998 const char *selector
,
999 std::vector
<const char *> *symbol_names
)
1001 const char *symname
= NULL
;
1004 char *nclass
= NULL
;
1005 char *ncategory
= NULL
;
1006 char *nselector
= NULL
;
1008 static char *tmp
= NULL
;
1009 static unsigned int tmplen
= 0;
1011 gdb_assert (symbol_names
!= NULL
);
1013 for (objfile
*objfile
: current_program_space
->objfiles ())
1015 unsigned int *objc_csym
;
1017 /* The objfile_csym variable counts the number of ObjC methods
1018 that this objfile defines. We save that count as a private
1019 objfile data. If we have already determined that this objfile
1020 provides no ObjC methods, we can skip it entirely. */
1022 unsigned int objfile_csym
= 0;
1024 objc_csym
= objc_objfile_data
.get (objfile
);
1025 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1026 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1029 for (minimal_symbol
*msymbol
: objfile
->msymbols ())
1033 /* Check the symbol name first as this can be done entirely without
1034 sending any query to the target. */
1035 symname
= msymbol
->natural_name ();
1036 if (symname
== NULL
)
1039 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1040 /* Not a method name. */
1045 /* Now that thinks are a bit sane, clean up the symname. */
1046 while ((strlen (symname
) + 1) >= tmplen
)
1048 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1049 tmp
= (char *) xrealloc (tmp
, tmplen
);
1051 strcpy (tmp
, symname
);
1053 if (parse_method (tmp
, &ntype
, &nclass
,
1054 &ncategory
, &nselector
) == NULL
)
1057 if ((type
!= '\0') && (ntype
!= type
))
1060 if ((theclass
!= NULL
)
1061 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1064 if ((category
!= NULL
) &&
1065 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1068 if ((selector
!= NULL
) &&
1069 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1072 symbol_names
->push_back (symname
);
1075 if (objc_csym
== NULL
)
1076 objc_csym
= objc_objfile_data
.emplace (objfile
, objfile_csym
);
1078 /* Count of ObjC methods in this objfile should be constant. */
1079 gdb_assert (*objc_csym
== objfile_csym
);
1083 /* Uniquify a vector of strings. */
1086 uniquify_strings (std::vector
<const char *> *strings
)
1088 if (strings
->empty ())
1091 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1092 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1097 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1099 * Input: a string representing a selector
1100 * a pointer to an array of symbol pointers
1101 * possibly a pointer to a symbol found by the caller.
1103 * Output: number of methods that implement that selector. Side
1104 * effects: The array of symbol pointers is filled with matching syms.
1106 * By analogy with function "find_methods" (symtab.c), builds a list
1107 * of symbols matching the ambiguous input, so that "decode_line_2"
1108 * (symtab.c) can list them and ask the user to choose one or more.
1109 * In this case the matches are objective c methods
1110 * ("implementations") matching an objective c selector.
1112 * Note that it is possible for a normal (c-style) function to have
1113 * the same name as an objective c selector. To prevent the selector
1114 * from eclipsing the function, we allow the caller (decode_line_1) to
1115 * search for such a function first, and if it finds one, pass it in
1116 * to us. We will then integrate it into the list. We also search
1117 * for one here, among the minsyms.
1119 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1120 * into two parts: debuggable (struct symbol) syms, and
1121 * non_debuggable (struct minimal_symbol) syms. The debuggable
1122 * ones will come first, before NUM_DEBUGGABLE (which will thus
1123 * be the index of the first non-debuggable one).
1127 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1130 char *theclass
= NULL
;
1131 char *category
= NULL
;
1132 char *selector
= NULL
;
1137 int selector_case
= 0;
1139 gdb_assert (symbol_names
!= NULL
);
1141 buf
= (char *) alloca (strlen (method
) + 1);
1142 strcpy (buf
, method
);
1143 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1147 strcpy (buf
, method
);
1148 tmp
= parse_selector (buf
, &selector
);
1156 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1158 /* If we hit the "selector" case, and we found some methods, then
1159 add the selector itself as a symbol, if it exists. */
1160 if (selector_case
&& !symbol_names
->empty ())
1162 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1166 symbol_names
->push_back (sym
->natural_name ());
1169 struct bound_minimal_symbol msym
1170 = lookup_minimal_symbol (selector
, 0, 0);
1172 if (msym
.minsym
!= NULL
)
1173 symbol_names
->push_back (msym
.minsym
->natural_name ());
1177 uniquify_strings (symbol_names
);
1179 return method
+ (tmp
- buf
);
1183 print_object_command (const char *args
, int from_tty
)
1185 struct value
*object
, *function
, *description
;
1186 CORE_ADDR string_addr
, object_addr
;
1190 if (!args
|| !*args
)
1192 "The 'print-object' command requires an argument (an Objective-C object)");
1195 expression_up expr
= parse_expression (args
);
1198 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1199 expr
.get (), &pc
, EVAL_NORMAL
);
1202 /* Validate the address for sanity. */
1203 object_addr
= value_as_long (object
);
1204 read_memory (object_addr
, &c
, 1);
1206 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1207 if (function
== NULL
)
1208 error (_("Unable to locate _NSPrintForDebugger in child process"));
1210 description
= call_function_by_hand (function
, NULL
, object
);
1212 string_addr
= value_as_long (description
);
1213 if (string_addr
== 0)
1214 error (_("object returns null description"));
1216 read_memory (string_addr
+ i
++, &c
, 1);
1219 { /* Read and print characters up to EOS. */
1221 printf_filtered ("%c", c
);
1222 read_memory (string_addr
+ i
++, &c
, 1);
1225 printf_filtered(_("<object returns empty description>"));
1226 printf_filtered ("\n");
1229 /* The data structure 'methcalls' is used to detect method calls (thru
1230 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1231 * and ultimately find the method being called.
1234 struct objc_methcall
{
1236 /* Return instance method to be called. */
1237 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1238 /* Start of pc range corresponding to method invocation. */
1240 /* End of pc range corresponding to method invocation. */
1244 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1245 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1246 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1247 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1249 static struct objc_methcall methcalls
[] = {
1250 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1251 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1252 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1253 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1254 { "_objc_getClass", NULL
, 0, 0},
1255 { "_objc_getMetaClass", NULL
, 0, 0}
1258 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1260 /* The following function, "find_objc_msgsend", fills in the data
1261 * structure "objc_msgs" by finding the addresses of each of the
1262 * (currently four) functions that it holds (of which objc_msgSend is
1263 * the first). This must be called each time symbols are loaded, in
1264 * case the functions have moved for some reason.
1268 find_objc_msgsend (void)
1272 for (i
= 0; i
< nmethcalls
; i
++)
1274 struct bound_minimal_symbol func
;
1276 /* Try both with and without underscore. */
1277 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1278 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1280 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1282 if (func
.minsym
== NULL
)
1284 methcalls
[i
].begin
= 0;
1285 methcalls
[i
].end
= 0;
1289 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1290 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1294 /* find_objc_msgcall (replaces pc_off_limits)
1296 * ALL that this function now does is to determine whether the input
1297 * address ("pc") is the address of one of the Objective-C message
1298 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1299 * if so, it returns the address of the method that will be called.
1301 * The old function "pc_off_limits" used to do a lot of other things
1302 * in addition, such as detecting shared library jump stubs and
1303 * returning the address of the shlib function that would be called.
1304 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1305 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1306 * dependent modules.
1310 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1316 if (f (pc
, new_pc
) == 0)
1319 catch (const gdb_exception
&ex
)
1321 exception_fprintf (gdb_stderr
, ex
,
1322 "Unable to determine target of "
1323 "Objective-C method call (ignoring):\n");
1330 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1334 find_objc_msgsend ();
1340 for (i
= 0; i
< nmethcalls
; i
++)
1341 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1343 if (methcalls
[i
].stop_at
!= NULL
)
1344 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1353 void _initialize_objc_language ();
1355 _initialize_objc_language ()
1357 add_info ("selectors", info_selectors_command
,
1358 _("All Objective-C selectors, or those matching REGEXP."));
1359 add_info ("classes", info_classes_command
,
1360 _("All Objective-C classes, or those matching REGEXP."));
1361 add_com ("print-object", class_vars
, print_object_command
,
1362 _("Ask an Objective-C object to print itself."));
1363 add_com_alias ("po", "print-object", class_vars
, 1);
1367 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1368 struct objc_method
*method
)
1370 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1372 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1373 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1374 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1377 static unsigned long
1378 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1380 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1382 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1386 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1387 unsigned long num
, struct objc_method
*method
)
1389 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1390 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1394 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1395 struct objc_object
*object
)
1397 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1399 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1403 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1404 struct objc_super
*super
)
1406 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1408 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1409 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1413 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1414 struct objc_class
*theclass
)
1416 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1418 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1419 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1420 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1421 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1422 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1423 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1425 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1426 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1427 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1428 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1432 find_implementation_from_class (struct gdbarch
*gdbarch
,
1433 CORE_ADDR theclass
, CORE_ADDR sel
)
1435 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1436 CORE_ADDR subclass
= theclass
;
1438 while (subclass
!= 0)
1441 struct objc_class class_str
;
1442 unsigned mlistnum
= 0;
1444 read_objc_class (gdbarch
, subclass
, &class_str
);
1449 unsigned long nmethods
;
1452 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1458 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1460 for (i
= 0; i
< nmethods
; i
++)
1462 struct objc_method meth_str
;
1464 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1466 if (meth_str
.name
== sel
)
1467 /* FIXME: hppa arch was doing a pointer dereference
1468 here. There needs to be a better way to do that. */
1469 return meth_str
.imp
;
1473 subclass
= class_str
.super_class
;
1480 find_implementation (struct gdbarch
*gdbarch
,
1481 CORE_ADDR object
, CORE_ADDR sel
)
1483 struct objc_object ostr
;
1487 read_objc_object (gdbarch
, object
, &ostr
);
1491 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1495 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1497 struct frame_info
*frame
= get_current_frame ();
1498 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1499 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1505 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1506 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1508 res
= find_implementation (gdbarch
, object
, sel
);
1517 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1519 struct frame_info
*frame
= get_current_frame ();
1520 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1521 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1527 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1528 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1530 res
= find_implementation (gdbarch
, object
, sel
);
1539 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1541 struct frame_info
*frame
= get_current_frame ();
1542 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1543 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1545 struct objc_super sstr
;
1551 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1552 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1554 read_objc_super (gdbarch
, super
, &sstr
);
1555 if (sstr
.theclass
== 0)
1558 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1567 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1569 struct frame_info
*frame
= get_current_frame ();
1570 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1571 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1573 struct objc_super sstr
;
1579 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1580 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1582 read_objc_super (gdbarch
, super
, &sstr
);
1583 if (sstr
.theclass
== 0)
1586 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);