1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2016 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"
55 CORE_ADDR super_class
;
77 static const struct objfile_data
*objc_objfile_data
;
79 /* Lookup a structure type named "struct NAME", visible in lexical
80 block BLOCK. If NOERR is nonzero, return zero if NAME is not
84 lookup_struct_typedef (char *name
, const struct block
*block
, int noerr
)
88 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0).symbol
;
95 error (_("No struct type named %s."), name
);
97 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
102 error (_("This context has class, union or enum %s, not a struct."),
109 lookup_objc_class (struct gdbarch
*gdbarch
, char *classname
)
111 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
112 struct value
* function
, *classval
;
114 if (! target_has_execution
)
116 /* Can't call into inferior to lookup class. */
120 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0).minsym
)
121 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
122 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym
)
123 function
= find_function_in_inferior("objc_lookup_class", NULL
);
126 complaint (&symfile_complaints
,
127 _("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
,
138 lookup_child_selector (struct gdbarch
*gdbarch
, char *selname
)
140 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
141 struct value
* function
, *selstring
;
143 if (! target_has_execution
)
145 /* Can't call into inferior to lookup selector. */
149 if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym
)
150 function
= find_function_in_inferior("sel_getUid", NULL
);
151 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym
)
152 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
155 complaint (&symfile_complaints
,
156 _("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
, 1, &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
, 1, &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
, 1, &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
, 3, &stringValue
[0]);
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. */
284 /* la_sniff_from_mangled_name for ObjC. */
287 objc_sniff_from_mangled_name (const char *mangled
, char **demangled
)
289 *demangled
= objc_demangle (mangled
, 0);
290 return *demangled
!= NULL
;
293 /* Determine if we are currently in the Objective-C dispatch function.
294 If so, get the address of the method function that the dispatcher
295 would call and use that as the function to step into instead. Also
296 skip over the trampoline for the function (if any). This is better
297 for the user since they are only interested in stepping into the
298 method function anyway. */
300 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
302 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
303 CORE_ADDR real_stop_pc
;
304 CORE_ADDR method_stop_pc
;
306 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
308 if (real_stop_pc
!= 0)
309 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
311 find_objc_msgcall (stop_pc
, &method_stop_pc
);
315 real_stop_pc
= gdbarch_skip_trampoline_code
316 (gdbarch
, frame
, method_stop_pc
);
317 if (real_stop_pc
== 0)
318 real_stop_pc
= method_stop_pc
;
325 /* Table mapping opcodes into strings for printing operators
326 and precedences of the operators. */
328 static const struct op_print objc_op_print_tab
[] =
330 {",", BINOP_COMMA
, PREC_COMMA
, 0},
331 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
332 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
333 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
334 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
335 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
336 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
337 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
338 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
339 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
340 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
341 {">", BINOP_GTR
, PREC_ORDER
, 0},
342 {"<", BINOP_LESS
, PREC_ORDER
, 0},
343 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
344 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
345 {"+", BINOP_ADD
, PREC_ADD
, 0},
346 {"-", BINOP_SUB
, PREC_ADD
, 0},
347 {"*", BINOP_MUL
, PREC_MUL
, 0},
348 {"/", BINOP_DIV
, PREC_MUL
, 0},
349 {"%", BINOP_REM
, PREC_MUL
, 0},
350 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
351 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
352 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
353 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
354 {"*", UNOP_IND
, PREC_PREFIX
, 0},
355 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
356 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
357 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
358 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
359 {NULL
, OP_NULL
, PREC_NULL
, 0}
362 static const char *objc_extensions
[] =
367 const struct language_defn objc_language_defn
= {
368 "objective-c", /* Language name */
376 &exp_descriptor_standard
,
380 c_printchar
, /* Print a character constant */
381 c_printstr
, /* Function to print string constant */
383 c_print_type
, /* Print a type using appropriate syntax */
384 c_print_typedef
, /* Print a typedef using appropriate syntax */
385 c_val_print
, /* Print a value using appropriate syntax */
386 c_value_print
, /* Print a top-level value */
387 default_read_var_value
, /* la_read_var_value */
388 objc_skip_trampoline
, /* Language specific skip_trampoline */
389 "self", /* name_of_this */
390 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
391 basic_lookup_transparent_type
,/* lookup_transparent_type */
392 objc_demangle
, /* Language specific symbol demangler */
393 objc_sniff_from_mangled_name
,
394 NULL
, /* Language specific
395 class_name_from_physname */
396 objc_op_print_tab
, /* Expression operators for printing */
397 1, /* C-style arrays */
398 0, /* String lower bound */
399 default_word_break_characters
,
400 default_make_symbol_completion_list
,
401 c_language_arch_info
,
402 default_print_array_index
,
403 default_pass_by_reference
,
405 NULL
, /* la_get_symbol_name_cmp */
406 iterate_over_symbols
,
415 * Following functions help construct Objective-C message calls.
418 struct selname
/* For parsing Objective-C. */
420 struct selname
*next
;
425 static int msglist_len
;
426 static struct selname
*selname_chain
;
427 static char *msglist_sel
;
432 struct selname
*newobj
= XNEW (struct selname
);
434 newobj
->next
= selname_chain
;
435 newobj
->msglist_len
= msglist_len
;
436 newobj
->msglist_sel
= msglist_sel
;
438 msglist_sel
= (char *)xmalloc(1);
440 selname_chain
= newobj
;
444 add_msglist(struct stoken
*str
, int addcolon
)
450 if (str
== 0) /* Unnamed arg, or... */
452 if (addcolon
== 0) /* variable number of args. */
465 len
= plen
+ strlen(msglist_sel
) + 2;
466 s
= (char *)xmalloc(len
);
467 strcpy(s
, msglist_sel
);
482 end_msglist (struct parser_state
*ps
)
484 int val
= msglist_len
;
485 struct selname
*sel
= selname_chain
;
486 char *p
= msglist_sel
;
489 selname_chain
= sel
->next
;
490 msglist_len
= sel
->msglist_len
;
491 msglist_sel
= sel
->msglist_sel
;
492 selid
= lookup_child_selector (parse_gdbarch (ps
), p
);
494 error (_("Can't find selector \"%s\""), p
);
495 write_exp_elt_longcst (ps
, selid
);
497 write_exp_elt_longcst (ps
, val
); /* Number of args */
504 * Function: specialcmp (const char *a, const char *b)
506 * Special strcmp: treats ']' and ' ' as end-of-string.
507 * Used for qsorting lists of objc methods (either by class or selector).
511 specialcmp (const char *a
, const char *b
)
513 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
519 if (*a
&& *a
!= ' ' && *a
!= ']')
520 return 1; /* a is longer therefore greater. */
521 if (*b
&& *b
!= ' ' && *b
!= ']')
522 return -1; /* a is shorter therefore lesser. */
523 return 0; /* a and b are identical. */
527 * Function: compare_selectors (const void *, const void *)
529 * Comparison function for use with qsort. Arguments are symbols or
530 * msymbols Compares selector part of objc method name alphabetically.
534 compare_selectors (const void *a
, const void *b
)
536 const char *aname
, *bname
;
538 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
539 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
540 if (aname
== NULL
|| bname
== NULL
)
541 error (_("internal: compare_selectors(1)"));
543 aname
= strchr(aname
, ' ');
544 bname
= strchr(bname
, ' ');
545 if (aname
== NULL
|| bname
== NULL
)
546 error (_("internal: compare_selectors(2)"));
548 return specialcmp (aname
+1, bname
+1);
552 * Function: selectors_info (regexp, from_tty)
554 * Implements the "Info selectors" command. Takes an optional regexp
555 * arg. Lists all objective c selectors that match the regexp. Works
556 * by grepping thru all symbols for objective c methods. Output list
557 * is sorted and uniqued.
561 selectors_info (char *regexp
, int from_tty
)
563 struct objfile
*objfile
;
564 struct minimal_symbol
*msymbol
;
572 struct symbol
**sym_arr
;
576 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
579 if (*regexp
== '+' || *regexp
== '-')
580 { /* User wants only class methods or only instance methods. */
581 plusminus
= *regexp
++;
582 while (*regexp
== ' ' || *regexp
== '\t')
586 strcpy(myregexp
, ".*]");
589 /* Allow a few extra bytes because of the strcat below. */
590 if (sizeof (myregexp
) < strlen (regexp
) + 4)
591 error (_("Regexp is too long: %s"), regexp
);
592 strcpy(myregexp
, regexp
);
593 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
594 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
596 strcat(myregexp
, ".*]");
602 val
= re_comp (myregexp
);
604 error (_("Invalid regexp (%s): %s"), val
, regexp
);
607 /* First time thru is JUST to get max length and count. */
608 ALL_MSYMBOLS (objfile
, msymbol
)
611 name
= MSYMBOL_NATURAL_NAME (msymbol
);
613 && (name
[0] == '-' || name
[0] == '+')
614 && name
[1] == '[') /* Got a method name. */
616 /* Filter for class/instance methods. */
617 if (plusminus
&& name
[0] != plusminus
)
619 /* Find selector part. */
620 name
= (char *) strchr (name
+2, ' ');
623 complaint (&symfile_complaints
,
624 _("Bad method name '%s'"),
625 MSYMBOL_NATURAL_NAME (msymbol
));
628 if (regexp
== NULL
|| re_exec(++name
) != 0)
630 const char *mystart
= name
;
631 const char *myend
= strchr (mystart
, ']');
633 if (myend
&& (myend
- mystart
> maxlen
))
634 maxlen
= myend
- mystart
; /* Get longest selector. */
641 printf_filtered (_("Selectors matching \"%s\":\n\n"),
642 regexp
? regexp
: "*");
644 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
646 ALL_MSYMBOLS (objfile
, msymbol
)
649 name
= MSYMBOL_NATURAL_NAME (msymbol
);
651 (name
[0] == '-' || name
[0] == '+') &&
652 name
[1] == '[') /* Got a method name. */
654 /* Filter for class/instance methods. */
655 if (plusminus
&& name
[0] != plusminus
)
657 /* Find selector part. */
658 name
= (char *) strchr(name
+2, ' ');
659 if (regexp
== NULL
|| re_exec(++name
) != 0)
660 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
664 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
666 /* Prevent compare on first iteration. */
668 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
673 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
674 name
= strchr (name
, ' ') + 1;
675 if (p
[0] && specialcmp(name
, p
) == 0)
676 continue; /* Seen this one already (not unique). */
678 /* Copy selector part. */
679 while (*name
&& *name
!= ']')
682 /* Print in columns. */
683 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
688 printf_filtered (_("No selectors matching \"%s\"\n"),
689 regexp
? regexp
: "*");
693 * Function: compare_classes (const void *, const void *)
695 * Comparison function for use with qsort. Arguments are symbols or
696 * msymbols Compares class part of objc method name alphabetically.
700 compare_classes (const void *a
, const void *b
)
702 const char *aname
, *bname
;
704 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
705 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
706 if (aname
== NULL
|| bname
== NULL
)
707 error (_("internal: compare_classes(1)"));
709 return specialcmp (aname
+1, bname
+1);
713 * Function: classes_info(regexp, from_tty)
715 * Implements the "info classes" command for objective c classes.
716 * Lists all objective c classes that match the optional regexp.
717 * Works by grepping thru the list of objective c methods. List will
718 * be sorted and uniqued (since one class may have many methods).
719 * BUGS: will not list a class that has no methods.
723 classes_info (char *regexp
, int from_tty
)
725 struct objfile
*objfile
;
726 struct minimal_symbol
*msymbol
;
734 struct symbol
**sym_arr
;
737 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
740 /* Allow a few extra bytes because of the strcat below. */
741 if (sizeof (myregexp
) < strlen (regexp
) + 4)
742 error (_("Regexp is too long: %s"), regexp
);
743 strcpy(myregexp
, regexp
);
744 if (myregexp
[strlen(myregexp
) - 1] == '$')
745 /* In the method name, the end of the class name is marked by ' '. */
746 myregexp
[strlen(myregexp
) - 1] = ' ';
748 strcat(myregexp
, ".* ");
753 val
= re_comp (myregexp
);
755 error (_("Invalid regexp (%s): %s"), val
, regexp
);
758 /* First time thru is JUST to get max length and count. */
759 ALL_MSYMBOLS (objfile
, msymbol
)
762 name
= MSYMBOL_NATURAL_NAME (msymbol
);
764 (name
[0] == '-' || name
[0] == '+') &&
765 name
[1] == '[') /* Got a method name. */
766 if (regexp
== NULL
|| re_exec(name
+2) != 0)
768 /* Compute length of classname part. */
769 const char *mystart
= name
+ 2;
770 const char *myend
= strchr (mystart
, ' ');
772 if (myend
&& (myend
- mystart
> maxlen
))
773 maxlen
= myend
- mystart
;
779 printf_filtered (_("Classes matching \"%s\":\n\n"),
780 regexp
? regexp
: "*");
781 sym_arr
= XALLOCAVEC (struct symbol
*, matches
);
783 ALL_MSYMBOLS (objfile
, msymbol
)
786 name
= MSYMBOL_NATURAL_NAME (msymbol
);
788 (name
[0] == '-' || name
[0] == '+') &&
789 name
[1] == '[') /* Got a method name. */
790 if (regexp
== NULL
|| re_exec(name
+2) != 0)
791 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
794 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
796 /* Prevent compare on first iteration. */
798 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
803 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
805 if (p
[0] && specialcmp(name
, p
) == 0)
806 continue; /* Seen this one already (not unique). */
808 /* Copy class part of method name. */
809 while (*name
&& *name
!= ' ')
812 /* Print in columns. */
813 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
818 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
822 parse_selector (char *method
, char **selector
)
828 char *nselector
= NULL
;
830 gdb_assert (selector
!= NULL
);
834 s1
= skip_spaces (s1
);
840 s1
= skip_spaces (s1
);
847 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
849 else if (isspace (*s2
))
851 else if ((*s2
== '\0') || (*s2
== '\''))
859 s2
= skip_spaces (s2
);
864 s2
= skip_spaces (s2
);
867 if (selector
!= NULL
)
868 *selector
= nselector
;
874 parse_method (char *method
, char *type
, char **theclass
,
875 char **category
, char **selector
)
883 char *ncategory
= NULL
;
884 char *nselector
= NULL
;
886 gdb_assert (type
!= NULL
);
887 gdb_assert (theclass
!= NULL
);
888 gdb_assert (category
!= NULL
);
889 gdb_assert (selector
!= NULL
);
893 s1
= skip_spaces (s1
);
899 s1
= skip_spaces (s1
);
901 if ((s1
[0] == '+') || (s1
[0] == '-'))
904 s1
= skip_spaces (s1
);
911 while (isalnum (*s1
) || (*s1
== '_'))
915 s2
= skip_spaces (s2
);
920 s2
= skip_spaces (s2
);
922 while (isalnum (*s2
) || (*s2
== '_'))
927 /* Truncate the class name now that we're not using the open paren. */
935 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
937 else if (isspace (*s2
))
948 s2
= skip_spaces (s2
);
954 s2
= skip_spaces (s2
);
959 if (theclass
!= NULL
)
961 if (category
!= NULL
)
962 *category
= ncategory
;
963 if (selector
!= NULL
)
964 *selector
= nselector
;
970 find_methods (char type
, const char *theclass
, const char *category
,
971 const char *selector
,
972 VEC (const_char_ptr
) **symbol_names
)
974 struct objfile
*objfile
= NULL
;
976 const char *symname
= NULL
;
980 char *ncategory
= NULL
;
981 char *nselector
= NULL
;
983 static char *tmp
= NULL
;
984 static unsigned int tmplen
= 0;
986 gdb_assert (symbol_names
!= NULL
);
988 ALL_OBJFILES (objfile
)
990 unsigned int *objc_csym
;
991 struct minimal_symbol
*msymbol
= NULL
;
993 /* The objfile_csym variable counts the number of ObjC methods
994 that this objfile defines. We save that count as a private
995 objfile data. If we have already determined that this objfile
996 provides no ObjC methods, we can skip it entirely. */
998 unsigned int objfile_csym
= 0;
1000 objc_csym
= (unsigned int *) objfile_data (objfile
, objc_objfile_data
);
1001 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1002 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1005 ALL_OBJFILE_MSYMBOLS (objfile
, msymbol
)
1009 /* Check the symbol name first as this can be done entirely without
1010 sending any query to the target. */
1011 symname
= MSYMBOL_NATURAL_NAME (msymbol
);
1012 if (symname
== NULL
)
1015 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1016 /* Not a method name. */
1021 /* Now that thinks are a bit sane, clean up the symname. */
1022 while ((strlen (symname
) + 1) >= tmplen
)
1024 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1025 tmp
= (char *) xrealloc (tmp
, tmplen
);
1027 strcpy (tmp
, symname
);
1029 if (parse_method (tmp
, &ntype
, &nclass
,
1030 &ncategory
, &nselector
) == NULL
)
1033 if ((type
!= '\0') && (ntype
!= type
))
1036 if ((theclass
!= NULL
)
1037 && ((nclass
== NULL
) || (strcmp (theclass
, nclass
) != 0)))
1040 if ((category
!= NULL
) &&
1041 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1044 if ((selector
!= NULL
) &&
1045 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1048 VEC_safe_push (const_char_ptr
, *symbol_names
, symname
);
1051 if (objc_csym
== NULL
)
1053 objc_csym
= XOBNEW (&objfile
->objfile_obstack
, unsigned int);
1054 *objc_csym
= objfile_csym
;
1055 set_objfile_data (objfile
, objc_objfile_data
, objc_csym
);
1058 /* Count of ObjC methods in this objfile should be constant. */
1059 gdb_assert (*objc_csym
== objfile_csym
);
1063 /* Uniquify a VEC of strings. */
1066 uniquify_strings (VEC (const_char_ptr
) **strings
)
1069 const char *elem
, *last
= NULL
;
1072 /* If the vector is empty, there's nothing to do. This explicit
1073 check is needed to avoid invoking qsort with NULL. */
1074 if (VEC_empty (const_char_ptr
, *strings
))
1077 qsort (VEC_address (const_char_ptr
, *strings
),
1078 VEC_length (const_char_ptr
, *strings
),
1079 sizeof (const_char_ptr
),
1082 for (ix
= 0; VEC_iterate (const_char_ptr
, *strings
, ix
, elem
); ++ix
)
1084 if (last
== NULL
|| strcmp (last
, elem
) != 0)
1087 VEC_replace (const_char_ptr
, *strings
, out
, elem
);
1092 VEC_truncate (const_char_ptr
, *strings
, out
);
1096 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1098 * Input: a string representing a selector
1099 * a pointer to an array of symbol pointers
1100 * possibly a pointer to a symbol found by the caller.
1102 * Output: number of methods that implement that selector. Side
1103 * effects: The array of symbol pointers is filled with matching syms.
1105 * By analogy with function "find_methods" (symtab.c), builds a list
1106 * of symbols matching the ambiguous input, so that "decode_line_2"
1107 * (symtab.c) can list them and ask the user to choose one or more.
1108 * In this case the matches are objective c methods
1109 * ("implementations") matching an objective c selector.
1111 * Note that it is possible for a normal (c-style) function to have
1112 * the same name as an objective c selector. To prevent the selector
1113 * from eclipsing the function, we allow the caller (decode_line_1) to
1114 * search for such a function first, and if it finds one, pass it in
1115 * to us. We will then integrate it into the list. We also search
1116 * for one here, among the minsyms.
1118 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1119 * into two parts: debuggable (struct symbol) syms, and
1120 * non_debuggable (struct minimal_symbol) syms. The debuggable
1121 * ones will come first, before NUM_DEBUGGABLE (which will thus
1122 * be the index of the first non-debuggable one).
1126 find_imps (const char *method
, VEC (const_char_ptr
) **symbol_names
)
1129 char *theclass
= NULL
;
1130 char *category
= NULL
;
1131 char *selector
= NULL
;
1136 int selector_case
= 0;
1138 gdb_assert (symbol_names
!= NULL
);
1140 buf
= (char *) alloca (strlen (method
) + 1);
1141 strcpy (buf
, method
);
1142 tmp
= parse_method (buf
, &type
, &theclass
, &category
, &selector
);
1146 strcpy (buf
, method
);
1147 tmp
= parse_selector (buf
, &selector
);
1155 find_methods (type
, theclass
, category
, selector
, symbol_names
);
1157 /* If we hit the "selector" case, and we found some methods, then
1158 add the selector itself as a symbol, if it exists. */
1159 if (selector_case
&& !VEC_empty (const_char_ptr
, *symbol_names
))
1161 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
,
1165 VEC_safe_push (const_char_ptr
, *symbol_names
,
1166 SYMBOL_NATURAL_NAME (sym
));
1169 struct bound_minimal_symbol msym
1170 = lookup_minimal_symbol (selector
, 0, 0);
1172 if (msym
.minsym
!= NULL
)
1173 VEC_safe_push (const_char_ptr
, *symbol_names
,
1174 MSYMBOL_NATURAL_NAME (msym
.minsym
));
1178 uniquify_strings (symbol_names
);
1180 return method
+ (tmp
- buf
);
1184 print_object_command (char *args
, int from_tty
)
1186 struct value
*object
, *function
, *description
;
1187 CORE_ADDR string_addr
, object_addr
;
1191 if (!args
|| !*args
)
1193 "The 'print-object' command requires an argument (an Objective-C object)");
1196 expression_up expr
= parse_expression (args
);
1199 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1200 expr
.get (), &pc
, EVAL_NORMAL
);
1203 /* Validate the address for sanity. */
1204 object_addr
= value_as_long (object
);
1205 read_memory (object_addr
, &c
, 1);
1207 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1208 if (function
== NULL
)
1209 error (_("Unable to locate _NSPrintForDebugger in child process"));
1211 description
= call_function_by_hand (function
, 1, &object
);
1213 string_addr
= value_as_long (description
);
1214 if (string_addr
== 0)
1215 error (_("object returns null description"));
1217 read_memory (string_addr
+ i
++, &c
, 1);
1220 { /* Read and print characters up to EOS. */
1222 printf_filtered ("%c", c
);
1223 read_memory (string_addr
+ i
++, &c
, 1);
1226 printf_filtered(_("<object returns empty description>"));
1227 printf_filtered ("\n");
1230 /* The data structure 'methcalls' is used to detect method calls (thru
1231 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1232 * and ultimately find the method being called.
1235 struct objc_methcall
{
1237 /* Return instance method to be called. */
1238 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1239 /* Start of pc range corresponding to method invocation. */
1241 /* End of pc range corresponding to method invocation. */
1245 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1246 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1247 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1248 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1250 static struct objc_methcall methcalls
[] = {
1251 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1252 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1253 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1254 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1255 { "_objc_getClass", NULL
, 0, 0},
1256 { "_objc_getMetaClass", NULL
, 0, 0}
1259 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1261 /* The following function, "find_objc_msgsend", fills in the data
1262 * structure "objc_msgs" by finding the addresses of each of the
1263 * (currently four) functions that it holds (of which objc_msgSend is
1264 * the first). This must be called each time symbols are loaded, in
1265 * case the functions have moved for some reason.
1269 find_objc_msgsend (void)
1273 for (i
= 0; i
< nmethcalls
; i
++)
1275 struct bound_minimal_symbol func
;
1277 /* Try both with and without underscore. */
1278 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
);
1279 if ((func
.minsym
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1281 func
= lookup_bound_minimal_symbol (methcalls
[i
].name
+ 1);
1283 if (func
.minsym
== NULL
)
1285 methcalls
[i
].begin
= 0;
1286 methcalls
[i
].end
= 0;
1290 methcalls
[i
].begin
= BMSYMBOL_VALUE_ADDRESS (func
);
1291 methcalls
[i
].end
= minimal_symbol_upper_bound (func
);
1295 /* find_objc_msgcall (replaces pc_off_limits)
1297 * ALL that this function now does is to determine whether the input
1298 * address ("pc") is the address of one of the Objective-C message
1299 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1300 * if so, it returns the address of the method that will be called.
1302 * The old function "pc_off_limits" used to do a lot of other things
1303 * in addition, such as detecting shared library jump stubs and
1304 * returning the address of the shlib function that would be called.
1305 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1306 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1307 * dependent modules.
1310 struct objc_submethod_helper_data
{
1311 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1317 find_objc_msgcall_submethod_helper (void * arg
)
1319 struct objc_submethod_helper_data
*s
=
1320 (struct objc_submethod_helper_data
*) arg
;
1322 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1329 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1333 struct objc_submethod_helper_data s
;
1339 if (catch_errors (find_objc_msgcall_submethod_helper
,
1341 "Unable to determine target of "
1342 "Objective-C method call (ignoring):\n",
1343 RETURN_MASK_ALL
) == 0)
1350 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1354 find_objc_msgsend ();
1360 for (i
= 0; i
< nmethcalls
; i
++)
1361 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1363 if (methcalls
[i
].stop_at
!= NULL
)
1364 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1373 /* -Wmissing-prototypes */
1374 extern initialize_file_ftype _initialize_objc_language
;
1377 _initialize_objc_language (void)
1379 add_language (&objc_language_defn
);
1380 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1381 _("All Objective-C selectors, or those matching REGEXP."));
1382 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1383 _("All Objective-C classes, or those matching REGEXP."));
1384 add_com ("print-object", class_vars
, print_object_command
,
1385 _("Ask an Objective-C object to print itself."));
1386 add_com_alias ("po", "print-object", class_vars
, 1);
1390 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1391 struct objc_method
*method
)
1393 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1395 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1396 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1397 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1400 static unsigned long
1401 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1403 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1405 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1409 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1410 unsigned long num
, struct objc_method
*method
)
1412 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1413 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1417 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1418 struct objc_object
*object
)
1420 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1422 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1426 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1427 struct objc_super
*super
)
1429 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1431 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1432 super
->theclass
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1436 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1437 struct objc_class
*theclass
)
1439 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1441 theclass
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1442 theclass
->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1443 theclass
->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1444 theclass
->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1445 theclass
->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1446 theclass
->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1448 theclass
->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1449 theclass
->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1450 theclass
->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1451 theclass
->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1455 find_implementation_from_class (struct gdbarch
*gdbarch
,
1456 CORE_ADDR theclass
, CORE_ADDR sel
)
1458 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1459 CORE_ADDR subclass
= theclass
;
1461 while (subclass
!= 0)
1464 struct objc_class class_str
;
1465 unsigned mlistnum
= 0;
1467 read_objc_class (gdbarch
, subclass
, &class_str
);
1472 unsigned long nmethods
;
1475 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1481 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1483 for (i
= 0; i
< nmethods
; i
++)
1485 struct objc_method meth_str
;
1487 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1489 if (meth_str
.name
== sel
)
1490 /* FIXME: hppa arch was doing a pointer dereference
1491 here. There needs to be a better way to do that. */
1492 return meth_str
.imp
;
1496 subclass
= class_str
.super_class
;
1503 find_implementation (struct gdbarch
*gdbarch
,
1504 CORE_ADDR object
, CORE_ADDR sel
)
1506 struct objc_object ostr
;
1510 read_objc_object (gdbarch
, object
, &ostr
);
1514 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1518 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1520 struct frame_info
*frame
= get_current_frame ();
1521 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1522 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1528 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1529 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1531 res
= find_implementation (gdbarch
, object
, sel
);
1540 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1542 struct frame_info
*frame
= get_current_frame ();
1543 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1544 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1550 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1551 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1553 res
= find_implementation (gdbarch
, object
, sel
);
1562 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1564 struct frame_info
*frame
= get_current_frame ();
1565 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1566 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1568 struct objc_super sstr
;
1574 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1575 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1577 read_objc_super (gdbarch
, super
, &sstr
);
1578 if (sstr
.theclass
== 0)
1581 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1590 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1592 struct frame_info
*frame
= get_current_frame ();
1593 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1594 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1596 struct objc_super sstr
;
1602 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1603 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1605 read_objc_super (gdbarch
, super
, &sstr
);
1606 if (sstr
.theclass
== 0)
1609 res
= find_implementation_from_class (gdbarch
, sstr
.theclass
, sel
);
1617 /* Provide a prototype to silence -Wmissing-prototypes. */
1618 extern initialize_file_ftype _initialize_objc_lang
;
1621 _initialize_objc_lang (void)
1623 objc_objfile_data
= register_objfile_data ();