1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2018 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_data
*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 (TYPE_CODE (SYMBOL_TYPE (sym
)) != 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 (&symfile_complaints
,
128 _("no way to lookup Objective-C classes"));
132 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
133 classval
= value_coerce_array (classval
);
134 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
140 lookup_child_selector (struct gdbarch
*gdbarch
, const char *selname
)
142 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
143 struct value
* function
, *selstring
;
145 if (! target_has_execution
)
147 /* Can't call into inferior to lookup selector. */
151 if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym
)
152 function
= find_function_in_inferior("sel_getUid", NULL
);
153 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym
)
154 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
157 complaint (&symfile_complaints
,
158 _("no way to lookup Objective-C selectors"));
162 selstring
= value_coerce_array (value_string (selname
,
163 strlen (selname
) + 1,
165 return value_as_long (call_function_by_hand (function
, NULL
, 1, &selstring
));
169 value_nsstring (struct gdbarch
*gdbarch
, char *ptr
, int len
)
171 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
172 struct value
*stringValue
[3];
173 struct value
*function
, *nsstringValue
;
177 if (!target_has_execution
)
178 return 0; /* Can't call into inferior to create NSString. */
180 stringValue
[2] = value_string(ptr
, len
, char_type
);
181 stringValue
[2] = value_coerce_array(stringValue
[2]);
182 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
183 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym
)
185 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
186 nsstringValue
= call_function_by_hand(function
,
187 NULL
, 1, &stringValue
[2]);
189 else if (lookup_minimal_symbol("istr", 0, 0).minsym
)
191 function
= find_function_in_inferior("istr", NULL
);
192 nsstringValue
= call_function_by_hand(function
, NULL
, 1, &stringValue
[2]);
194 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym
)
197 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
198 type
= builtin_type (gdbarch
)->builtin_long
;
200 stringValue
[0] = value_from_longest
201 (type
, lookup_objc_class (gdbarch
, "NSString"));
202 stringValue
[1] = value_from_longest
203 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
204 nsstringValue
= call_function_by_hand(function
, NULL
, 3, &stringValue
[0]);
207 error (_("NSString: internal error -- no way to create new NSString"));
209 sym
= lookup_struct_typedef("NSString", 0, 1);
211 sym
= lookup_struct_typedef("NXString", 0, 1);
213 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
215 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
217 deprecated_set_value_type (nsstringValue
, type
);
218 return nsstringValue
;
221 /* Objective-C name demangling. */
224 objc_demangle (const char *mangled
, int options
)
226 char *demangled
, *cp
;
228 if (mangled
[0] == '_' &&
229 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
232 cp
= demangled
= (char *) xmalloc (strlen (mangled
) + 2);
234 if (mangled
[1] == 'i')
235 *cp
++ = '-'; /* for instance method */
237 *cp
++ = '+'; /* for class method */
239 *cp
++ = '['; /* opening left brace */
240 strcpy(cp
, mangled
+3); /* Tack on the rest of the mangled name. */
242 while (*cp
&& *cp
== '_')
243 cp
++; /* Skip any initial underbars in class
246 cp
= strchr(cp
, '_');
247 if (!cp
) /* Find first non-initial underbar. */
249 xfree(demangled
); /* not mangled name */
252 if (cp
[1] == '_') /* Easy case: no category name. */
254 *cp
++ = ' '; /* Replace two '_' with one ' '. */
255 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
259 *cp
++ = '('; /* Less easy case: category name. */
260 cp
= strchr(cp
, '_');
263 xfree(demangled
); /* not mangled name */
267 *cp
++ = ' '; /* Overwriting 1st char of method name... */
268 strcpy(cp
, mangled
+ (cp
- demangled
)); /* Get it back. */
271 while (*cp
&& *cp
== '_')
272 cp
++; /* Skip any initial underbars in
277 *cp
= ':'; /* Replace remaining '_' with ':'. */
279 *cp
++ = ']'; /* closing right brace */
280 *cp
++ = 0; /* string terminator */
284 return NULL
; /* Not an objc mangled name. */
287 /* la_sniff_from_mangled_name for ObjC. */
290 objc_sniff_from_mangled_name (const char *mangled
, char **demangled
)
292 *demangled
= objc_demangle (mangled
, 0);
293 return *demangled
!= NULL
;
296 /* Determine if we are currently in the Objective-C dispatch function.
297 If so, get the address of the method function that the dispatcher
298 would call and use that as the function to step into instead. Also
299 skip over the trampoline for the function (if any). This is better
300 for the user since they are only interested in stepping into the
301 method function anyway. */
303 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
305 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
306 CORE_ADDR real_stop_pc
;
307 CORE_ADDR method_stop_pc
;
309 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
311 if (real_stop_pc
!= 0)
312 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
314 find_objc_msgcall (stop_pc
, &method_stop_pc
);
318 real_stop_pc
= gdbarch_skip_trampoline_code
319 (gdbarch
, frame
, method_stop_pc
);
320 if (real_stop_pc
== 0)
321 real_stop_pc
= method_stop_pc
;
328 /* Table mapping opcodes into strings for printing operators
329 and precedences of the operators. */
331 static const struct op_print objc_op_print_tab
[] =
333 {",", BINOP_COMMA
, PREC_COMMA
, 0},
334 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
335 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
336 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
337 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
338 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
339 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
340 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
341 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
342 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
343 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
344 {">", BINOP_GTR
, PREC_ORDER
, 0},
345 {"<", BINOP_LESS
, PREC_ORDER
, 0},
346 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
347 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
348 {"+", BINOP_ADD
, PREC_ADD
, 0},
349 {"-", BINOP_SUB
, PREC_ADD
, 0},
350 {"*", BINOP_MUL
, PREC_MUL
, 0},
351 {"/", BINOP_DIV
, PREC_MUL
, 0},
352 {"%", BINOP_REM
, PREC_MUL
, 0},
353 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
354 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
355 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
356 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
357 {"*", UNOP_IND
, PREC_PREFIX
, 0},
358 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
359 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
360 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
361 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
362 {NULL
, OP_NULL
, PREC_NULL
, 0}
365 static const char *objc_extensions
[] =
370 extern const struct language_defn objc_language_defn
= {
371 "objective-c", /* Language name */
379 &exp_descriptor_standard
,
383 c_printchar
, /* Print a character constant */
384 c_printstr
, /* Function to print string constant */
386 c_print_type
, /* Print a type using appropriate syntax */
387 c_print_typedef
, /* Print a typedef using appropriate syntax */
388 c_val_print
, /* Print a value using appropriate syntax */
389 c_value_print
, /* Print a top-level value */
390 default_read_var_value
, /* la_read_var_value */
391 objc_skip_trampoline
, /* Language specific skip_trampoline */
392 "self", /* name_of_this */
393 false, /* la_store_sym_names_in_linkage_form_p */
394 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
395 basic_lookup_transparent_type
,/* lookup_transparent_type */
396 objc_demangle
, /* Language specific symbol demangler */
397 objc_sniff_from_mangled_name
,
398 NULL
, /* Language specific
399 class_name_from_physname */
400 objc_op_print_tab
, /* Expression operators for printing */
401 1, /* C-style arrays */
402 0, /* String lower bound */
403 default_word_break_characters
,
404 default_collect_symbol_completion_matches
,
405 c_language_arch_info
,
406 default_print_array_index
,
407 default_pass_by_reference
,
409 c_watch_location_expression
,
410 NULL
, /* la_get_symbol_name_matcher */
411 iterate_over_symbols
,
412 default_search_name_hash
,
421 * Following functions help construct Objective-C message calls.
424 struct selname
/* For parsing Objective-C. */
426 struct selname
*next
;
431 static int msglist_len
;
432 static struct selname
*selname_chain
;
433 static char *msglist_sel
;
438 struct selname
*newobj
= XNEW (struct selname
);
440 newobj
->next
= selname_chain
;
441 newobj
->msglist_len
= msglist_len
;
442 newobj
->msglist_sel
= msglist_sel
;
444 msglist_sel
= (char *)xmalloc(1);
446 selname_chain
= newobj
;
450 add_msglist(struct stoken
*str
, int addcolon
)
456 if (str
== 0) /* Unnamed arg, or... */
458 if (addcolon
== 0) /* variable number of args. */
471 len
= plen
+ strlen(msglist_sel
) + 2;
472 s
= (char *)xmalloc(len
);
473 strcpy(s
, msglist_sel
);
488 end_msglist (struct parser_state
*ps
)
490 int val
= msglist_len
;
491 struct selname
*sel
= selname_chain
;
492 char *p
= msglist_sel
;
495 selname_chain
= sel
->next
;
496 msglist_len
= sel
->msglist_len
;
497 msglist_sel
= sel
->msglist_sel
;
498 selid
= lookup_child_selector (parse_gdbarch (ps
), p
);
500 error (_("Can't find selector \"%s\""), p
);
501 write_exp_elt_longcst (ps
, selid
);
503 write_exp_elt_longcst (ps
, val
); /* Number of args */
510 * Function: specialcmp (const char *a, const char *b)
512 * Special strcmp: treats ']' and ' ' as end-of-string.
513 * Used for qsorting lists of objc methods (either by class or selector).
517 specialcmp (const char *a
, const char *b
)
519 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
525 if (*a
&& *a
!= ' ' && *a
!= ']')
526 return 1; /* a is longer therefore greater. */
527 if (*b
&& *b
!= ' ' && *b
!= ']')
528 return -1; /* a is shorter therefore lesser. */
529 return 0; /* a and b are identical. */
533 * Function: compare_selectors (const void *, const void *)
535 * Comparison function for use with qsort. Arguments are symbols or
536 * msymbols Compares selector part of objc method name alphabetically.
540 compare_selectors (const void *a
, const void *b
)
542 const char *aname
, *bname
;
544 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
545 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
546 if (aname
== NULL
|| bname
== NULL
)
547 error (_("internal: compare_selectors(1)"));
549 aname
= strchr(aname
, ' ');
550 bname
= strchr(bname
, ' ');
551 if (aname
== NULL
|| bname
== NULL
)
552 error (_("internal: compare_selectors(2)"));
554 return specialcmp (aname
+1, bname
+1);
558 * Function: selectors_info (regexp, from_tty)
560 * Implements the "Info selectors" command. Takes an optional regexp
561 * arg. Lists all objective c selectors that match the regexp. Works
562 * by grepping thru all symbols for objective c methods. Output list
563 * is sorted and uniqued.
567 info_selectors_command (const char *regexp
, int from_tty
)
569 struct objfile
*objfile
;
570 struct minimal_symbol
*msymbol
;
578 struct symbol
**sym_arr
;
582 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
585 if (*regexp
== '+' || *regexp
== '-')
586 { /* User wants only class methods or only instance methods. */
587 plusminus
= *regexp
++;
588 while (*regexp
== ' ' || *regexp
== '\t')
592 strcpy(myregexp
, ".*]");
595 /* Allow a few extra bytes because of the strcat below. */
596 if (sizeof (myregexp
) < strlen (regexp
) + 4)
597 error (_("Regexp is too long: %s"), regexp
);
598 strcpy(myregexp
, regexp
);
599 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
600 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
602 strcat(myregexp
, ".*]");
608 val
= re_comp (myregexp
);
610 error (_("Invalid regexp (%s): %s"), val
, regexp
);
613 /* First time thru is JUST to get max length and count. */
614 ALL_MSYMBOLS (objfile
, msymbol
)
617 name
= MSYMBOL_NATURAL_NAME (msymbol
);
619 && (name
[0] == '-' || name
[0] == '+')
620 && name
[1] == '[') /* Got a method name. */
622 /* Filter for class/instance methods. */
623 if (plusminus
&& name
[0] != plusminus
)
625 /* Find selector part. */
626 name
= (char *) strchr (name
+2, ' ');
629 complaint (&symfile_complaints
,
630 _("Bad method name '%s'"),
631 MSYMBOL_NATURAL_NAME (msymbol
));
634 if (regexp
== NULL
|| re_exec(++name
) != 0)
636 const char *mystart
= name
;
637 const char *myend
= strchr (mystart
, ']');
639 if (myend
&& (myend
- mystart
> maxlen
))
640 maxlen
= myend
- mystart
; /* Get longest selector. */
647 printf_filtered (_("Selectors matching \"%s\":\n\n"),
648 regexp
? regexp
: "*");
650 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
652 ALL_MSYMBOLS (objfile
, msymbol
)
655 name
= MSYMBOL_NATURAL_NAME (msymbol
);
657 (name
[0] == '-' || name
[0] == '+') &&
658 name
[1] == '[') /* Got a method name. */
660 /* Filter for class/instance methods. */
661 if (plusminus
&& name
[0] != plusminus
)
663 /* Find selector part. */
664 name
= (char *) strchr(name
+2, ' ');
665 if (regexp
== NULL
|| re_exec(++name
) != 0)
666 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
670 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
672 /* Prevent compare on first iteration. */
674 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
679 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
680 name
= strchr (name
, ' ') + 1;
681 if (p
[0] && specialcmp(name
, p
) == 0)
682 continue; /* Seen this one already (not unique). */
684 /* Copy selector part. */
685 while (*name
&& *name
!= ']')
688 /* Print in columns. */
689 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
694 printf_filtered (_("No selectors matching \"%s\"\n"),
695 regexp
? regexp
: "*");
699 * Function: compare_classes (const void *, const void *)
701 * Comparison function for use with qsort. Arguments are symbols or
702 * msymbols Compares class part of objc method name alphabetically.
706 compare_classes (const void *a
, const void *b
)
708 const char *aname
, *bname
;
710 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
711 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
712 if (aname
== NULL
|| bname
== NULL
)
713 error (_("internal: compare_classes(1)"));
715 return specialcmp (aname
+1, bname
+1);
719 * Function: classes_info(regexp, from_tty)
721 * Implements the "info classes" command for objective c classes.
722 * Lists all objective c classes that match the optional regexp.
723 * Works by grepping thru the list of objective c methods. List will
724 * be sorted and uniqued (since one class may have many methods).
725 * BUGS: will not list a class that has no methods.
729 info_classes_command (const char *regexp
, int from_tty
)
731 struct objfile
*objfile
;
732 struct minimal_symbol
*msymbol
;
740 struct symbol
**sym_arr
;
743 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
746 /* Allow a few extra bytes because of the strcat below. */
747 if (sizeof (myregexp
) < strlen (regexp
) + 4)
748 error (_("Regexp is too long: %s"), regexp
);
749 strcpy(myregexp
, regexp
);
750 if (myregexp
[strlen(myregexp
) - 1] == '$')
751 /* In the method name, the end of the class name is marked by ' '. */
752 myregexp
[strlen(myregexp
) - 1] = ' ';
754 strcat(myregexp
, ".* ");
759 val
= re_comp (myregexp
);
761 error (_("Invalid regexp (%s): %s"), val
, regexp
);
764 /* First time thru is JUST to get max length and count. */
765 ALL_MSYMBOLS (objfile
, msymbol
)
768 name
= MSYMBOL_NATURAL_NAME (msymbol
);
770 (name
[0] == '-' || name
[0] == '+') &&
771 name
[1] == '[') /* Got a method name. */
772 if (regexp
== NULL
|| re_exec(name
+2) != 0)
774 /* Compute length of classname part. */
775 const char *mystart
= name
+ 2;
776 const char *myend
= strchr (mystart
, ' ');
778 if (myend
&& (myend
- mystart
> maxlen
))
779 maxlen
= myend
- mystart
;
785 printf_filtered (_("Classes matching \"%s\":\n\n"),
786 regexp
? regexp
: "*");
787 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
789 ALL_MSYMBOLS (objfile
, msymbol
)
792 name
= MSYMBOL_NATURAL_NAME (msymbol
);
794 (name
[0] == '-' || name
[0] == '+') &&
795 name
[1] == '[') /* Got a method name. */
796 if (regexp
== NULL
|| re_exec(name
+2) != 0)
797 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
800 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
802 /* Prevent compare on first iteration. */
804 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
809 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
811 if (p
[0] && specialcmp(name
, p
) == 0)
812 continue; /* Seen this one already (not unique). */
814 /* Copy class part of method name. */
815 while (*name
&& *name
!= ' ')
818 /* Print in columns. */
819 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
824 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
828 parse_selector (char *method
, char **selector
)
834 char *nselector
= NULL
;
836 gdb_assert (selector
!= NULL
);
840 s1
= skip_spaces (s1
);
846 s1
= skip_spaces (s1
);
853 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
855 else if (isspace (*s2
))
857 else if ((*s2
== '\0') || (*s2
== '\''))
865 s2
= skip_spaces (s2
);
870 s2
= skip_spaces (s2
);
873 if (selector
!= NULL
)
874 *selector
= nselector
;
880 parse_method (char *method
, char *type
, char **theclass
,
881 char **category
, char **selector
)
889 char *ncategory
= NULL
;
890 char *nselector
= NULL
;
892 gdb_assert (type
!= NULL
);
893 gdb_assert (theclass
!= NULL
);
894 gdb_assert (category
!= NULL
);
895 gdb_assert (selector
!= NULL
);
899 s1
= skip_spaces (s1
);
905 s1
= skip_spaces (s1
);
907 if ((s1
[0] == '+') || (s1
[0] == '-'))
910 s1
= skip_spaces (s1
);
917 while (isalnum (*s1
) || (*s1
== '_'))
921 s2
= skip_spaces (s2
);
926 s2
= skip_spaces (s2
);
928 while (isalnum (*s2
) || (*s2
== '_'))
933 /* Truncate the class name now that we're not using the open paren. */
941 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
943 else if (isspace (*s2
))
954 s2
= skip_spaces (s2
);
960 s2
= skip_spaces (s2
);
965 if (theclass
!= NULL
)
967 if (category
!= NULL
)
968 *category
= ncategory
;
969 if (selector
!= NULL
)
970 *selector
= nselector
;
976 find_methods (char type
, const char *theclass
, const char *category
,
977 const char *selector
,
978 std::vector
<const char *> *symbol_names
)
980 struct objfile
*objfile
= NULL
;
982 const char *symname
= NULL
;
986 char *ncategory
= NULL
;
987 char *nselector
= NULL
;
989 static char *tmp
= NULL
;
990 static unsigned int tmplen
= 0;
992 gdb_assert (symbol_names
!= NULL
);
994 ALL_OBJFILES (objfile
)
996 unsigned int *objc_csym
;
997 struct minimal_symbol
*msymbol
= NULL
;
999 /* The objfile_csym variable counts the number of ObjC methods
1000 that this objfile defines. We save that count as a private
1001 objfile data. If we have already determined that this objfile
1002 provides no ObjC methods, we can skip it entirely. */
1004 unsigned int objfile_csym
= 0;
1006 objc_csym
= (unsigned int *) objfile_data (objfile
, objc_objfile_data
);
1007 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1008 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1011 ALL_OBJFILE_MSYMBOLS (objfile
, msymbol
)
1015 /* Check the symbol name first as this can be done entirely without
1016 sending any query to the target. */
1017 symname
= MSYMBOL_NATURAL_NAME (msymbol
);
1018 if (symname
== NULL
)
1021 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1022 /* Not a method name. */
1027 /* Now that thinks are a bit sane, clean up the symname. */
1028 while ((strlen (symname
) + 1) >= tmplen
)
1030 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1031 tmp
= (char *) xrealloc (tmp
, tmplen
);
1033 strcpy (tmp
, symname
);
1035 if (parse_method (tmp
, &ntype
, &nclass
,
1036 &ncategory
, &nselector
) == NULL
)
1039 if ((type
!= '\0') && (ntype
!= type
))
1042 if ((theclass
!= NULL
)
1043 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1046 if ((category
!= NULL
) &&
1047 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1050 if ((selector
!= NULL
) &&
1051 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1054 symbol_names
->push_back (symname
);
1057 if (objc_csym
== NULL
)
1059 objc_csym
= XOBNEW (&objfile
->objfile_obstack
, unsigned int);
1060 *objc_csym
= objfile_csym
;
1061 set_objfile_data (objfile
, objc_objfile_data
, objc_csym
);
1064 /* Count of ObjC methods in this objfile should be constant. */
1065 gdb_assert (*objc_csym
== objfile_csym
);
1069 /* Uniquify a VEC of strings. */
1072 uniquify_strings (std::vector
<const char *> *strings
)
1074 if (strings
->empty ())
1077 std::sort (strings
->begin (), strings
->end (), compare_cstrings
);
1078 strings
->erase (std::unique (strings
->begin (), strings
->end (), streq
),
1083 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1085 * Input: a string representing a selector
1086 * a pointer to an array of symbol pointers
1087 * possibly a pointer to a symbol found by the caller.
1089 * Output: number of methods that implement that selector. Side
1090 * effects: The array of symbol pointers is filled with matching syms.
1092 * By analogy with function "find_methods" (symtab.c), builds a list
1093 * of symbols matching the ambiguous input, so that "decode_line_2"
1094 * (symtab.c) can list them and ask the user to choose one or more.
1095 * In this case the matches are objective c methods
1096 * ("implementations") matching an objective c selector.
1098 * Note that it is possible for a normal (c-style) function to have
1099 * the same name as an objective c selector. To prevent the selector
1100 * from eclipsing the function, we allow the caller (decode_line_1) to
1101 * search for such a function first, and if it finds one, pass it in
1102 * to us. We will then integrate it into the list. We also search
1103 * for one here, among the minsyms.
1105 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1106 * into two parts: debuggable (struct symbol) syms, and
1107 * non_debuggable (struct minimal_symbol) syms. The debuggable
1108 * ones will come first, before NUM_DEBUGGABLE (which will thus
1109 * be the index of the first non-debuggable one).
1113 find_imps (const char *method
, std::vector
<const char *> *symbol_names
)
1116 char *theclass
= NULL
;
1117 char *category
= NULL
;
1118 char *selector
= NULL
;
1123 int selector_case
= 0;
1125 gdb_assert (symbol_names
!= NULL
);
1127 buf
= (char *) alloca (strlen (method
) + 1);
1128 strcpy (buf
, method
);
1129 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1133 strcpy (buf
, method
);
1134 tmp
= parse_selector (buf
, &selector
);
1142 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1144 /* If we hit the "selector" case, and we found some methods, then
1145 add the selector itself as a symbol, if it exists. */
1146 if (selector_case
&& !symbol_names
->empty ())
1148 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1152 symbol_names
->push_back (SYMBOL_NATURAL_NAME (sym
));
1155 struct bound_minimal_symbol msym
1156 = lookup_minimal_symbol (selector
, 0, 0);
1158 if (msym
.minsym
!= NULL
)
1159 symbol_names
->push_back (MSYMBOL_NATURAL_NAME (msym
.minsym
));
1163 uniquify_strings (symbol_names
);
1165 return method
+ (tmp
- buf
);
1169 print_object_command (const char *args
, int from_tty
)
1171 struct value
*object
, *function
, *description
;
1172 CORE_ADDR string_addr
, object_addr
;
1176 if (!args
|| !*args
)
1178 "The 'print-object' command requires an argument (an Objective-C object)");
1181 expression_up expr
= parse_expression (args
);
1184 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1185 expr
.get (), &pc
, EVAL_NORMAL
);
1188 /* Validate the address for sanity. */
1189 object_addr
= value_as_long (object
);
1190 read_memory (object_addr
, &c
, 1);
1192 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1193 if (function
== NULL
)
1194 error (_("Unable to locate _NSPrintForDebugger in child process"));
1196 description
= call_function_by_hand (function
, NULL
, 1, &object
);
1198 string_addr
= value_as_long (description
);
1199 if (string_addr
== 0)
1200 error (_("object returns null description"));
1202 read_memory (string_addr
+ i
++, &c
, 1);
1205 { /* Read and print characters up to EOS. */
1207 printf_filtered ("%c", c
);
1208 read_memory (string_addr
+ i
++, &c
, 1);
1211 printf_filtered(_("<object returns empty description>"));
1212 printf_filtered ("\n");
1215 /* The data structure 'methcalls' is used to detect method calls (thru
1216 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1217 * and ultimately find the method being called.
1220 struct objc_methcall
{
1222 /* Return instance method to be called. */
1223 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1224 /* Start of pc range corresponding to method invocation. */
1226 /* End of pc range corresponding to method invocation. */
1230 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1231 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1232 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1233 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1235 static struct objc_methcall methcalls
[] = {
1236 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1237 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1238 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1239 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1240 { "_objc_getClass", NULL
, 0, 0},
1241 { "_objc_getMetaClass", NULL
, 0, 0}
1244 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1246 /* The following function, "find_objc_msgsend", fills in the data
1247 * structure "objc_msgs" by finding the addresses of each of the
1248 * (currently four) functions that it holds (of which objc_msgSend is
1249 * the first). This must be called each time symbols are loaded, in
1250 * case the functions have moved for some reason.
1254 find_objc_msgsend (void)
1258 for (i
= 0; i
< nmethcalls
; i
++)
1260 struct bound_minimal_symbol func
;
1262 /* Try both with and without underscore. */
1263 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1264 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1266 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1268 if (func
.minsym
== NULL
)
1270 methcalls
[i
].begin
= 0;
1271 methcalls
[i
].end
= 0;
1275 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1276 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1280 /* find_objc_msgcall (replaces pc_off_limits)
1282 * ALL that this function now does is to determine whether the input
1283 * address ("pc") is the address of one of the Objective-C message
1284 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1285 * if so, it returns the address of the method that will be called.
1287 * The old function "pc_off_limits" used to do a lot of other things
1288 * in addition, such as detecting shared library jump stubs and
1289 * returning the address of the shlib function that would be called.
1290 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1291 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1292 * dependent modules.
1296 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1302 if (f (pc
, new_pc
) == 0)
1305 CATCH (ex
, RETURN_MASK_ALL
)
1307 exception_fprintf (gdb_stderr
, ex
,
1308 "Unable to determine target of "
1309 "Objective-C method call (ignoring):\n");
1317 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1321 find_objc_msgsend ();
1327 for (i
= 0; i
< nmethcalls
; i
++)
1328 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1330 if (methcalls
[i
].stop_at
!= NULL
)
1331 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1341 _initialize_objc_language (void)
1343 add_info ("selectors", info_selectors_command
,
1344 _("All Objective-C selectors, or those matching REGEXP."));
1345 add_info ("classes", info_classes_command
,
1346 _("All Objective-C classes, or those matching REGEXP."));
1347 add_com ("print-object", class_vars
, print_object_command
,
1348 _("Ask an Objective-C object to print itself."));
1349 add_com_alias ("po", "print-object", class_vars
, 1);
1353 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1354 struct objc_method
*method
)
1356 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1358 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1359 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1360 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1363 static unsigned long
1364 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1366 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1368 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1372 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1373 unsigned long num
, struct objc_method
*method
)
1375 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1376 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1380 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1381 struct objc_object
*object
)
1383 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1385 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1389 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1390 struct objc_super
*super
)
1392 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1394 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1395 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1399 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1400 struct objc_class
*theclass
)
1402 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1404 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1405 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1406 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1407 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1408 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1409 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1411 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1412 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1413 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1414 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1418 find_implementation_from_class (struct gdbarch
*gdbarch
,
1419 CORE_ADDR theclass
, CORE_ADDR sel
)
1421 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1422 CORE_ADDR subclass
= theclass
;
1424 while (subclass
!= 0)
1427 struct objc_class class_str
;
1428 unsigned mlistnum
= 0;
1430 read_objc_class (gdbarch
, subclass
, &class_str
);
1435 unsigned long nmethods
;
1438 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1444 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1446 for (i
= 0; i
< nmethods
; i
++)
1448 struct objc_method meth_str
;
1450 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1452 if (meth_str
.name
== sel
)
1453 /* FIXME: hppa arch was doing a pointer dereference
1454 here. There needs to be a better way to do that. */
1455 return meth_str
.imp
;
1459 subclass
= class_str
.super_class
;
1466 find_implementation (struct gdbarch
*gdbarch
,
1467 CORE_ADDR object
, CORE_ADDR sel
)
1469 struct objc_object ostr
;
1473 read_objc_object (gdbarch
, object
, &ostr
);
1477 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1481 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1483 struct frame_info
*frame
= get_current_frame ();
1484 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1485 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1491 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1492 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1494 res
= find_implementation (gdbarch
, object
, sel
);
1503 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1505 struct frame_info
*frame
= get_current_frame ();
1506 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1507 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1513 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1514 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1516 res
= find_implementation (gdbarch
, object
, sel
);
1525 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1527 struct frame_info
*frame
= get_current_frame ();
1528 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1529 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1531 struct objc_super sstr
;
1537 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1538 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1540 read_objc_super (gdbarch
, super
, &sstr
);
1541 if (sstr
.theclass
== 0)
1544 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1553 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1555 struct frame_info
*frame
= get_current_frame ();
1556 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1557 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1559 struct objc_super sstr
;
1565 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1566 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1568 read_objc_super (gdbarch
, super
, &sstr
);
1569 if (sstr
.theclass
== 0)
1572 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1581 _initialize_objc_lang (void)
1583 objc_objfile_data
= register_objfile_data ();