1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2013 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"
30 #include "objc-lang.h"
31 #include "exceptions.h"
32 #include "complaints.h"
36 #include "gdb_string.h" /* for strchr */
37 #include "target.h" /* for target_has_execution */
41 #include "gdb_regex.h"
46 #include "gdb_assert.h"
47 #include "cli/cli-utils.h"
57 CORE_ADDR super_class
;
79 static const struct objfile_data
*objc_objfile_data
;
81 /* Lookup a structure type named "struct NAME", visible in lexical
82 block BLOCK. If NOERR is nonzero, return zero if NAME is not
86 lookup_struct_typedef (char *name
, const struct block
*block
, int noerr
)
90 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
97 error (_("No struct type named %s."), name
);
99 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
104 error (_("This context has class, union or enum %s, not a struct."),
111 lookup_objc_class (struct gdbarch
*gdbarch
, char *classname
)
113 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
114 struct value
* function
, *classval
;
116 if (! target_has_execution
)
118 /* Can't call into inferior to lookup class. */
122 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
123 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
124 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
125 function
= find_function_in_inferior("objc_lookup_class", NULL
);
128 complaint (&symfile_complaints
,
129 _("no way to lookup Objective-C classes"));
133 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
134 classval
= value_coerce_array (classval
);
135 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
140 lookup_child_selector (struct gdbarch
*gdbarch
, 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))
152 function
= find_function_in_inferior("sel_getUid", NULL
);
153 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
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
, 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))
185 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
186 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
188 else if (lookup_minimal_symbol("istr", 0, 0))
190 function
= find_function_in_inferior("istr", NULL
);
191 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
193 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
196 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
197 type
= builtin_type (gdbarch
)->builtin_long
;
199 stringValue
[0] = value_from_longest
200 (type
, lookup_objc_class (gdbarch
, "NSString"));
201 stringValue
[1] = value_from_longest
202 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
203 nsstringValue
= call_function_by_hand(function
, 3, &stringValue
[0]);
206 error (_("NSString: internal error -- no way to create new NSString"));
208 sym
= lookup_struct_typedef("NSString", 0, 1);
210 sym
= lookup_struct_typedef("NXString", 0, 1);
212 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
214 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
216 deprecated_set_value_type (nsstringValue
, type
);
217 return nsstringValue
;
220 /* Objective-C name demangling. */
223 objc_demangle (const char *mangled
, int options
)
225 char *demangled
, *cp
;
227 if (mangled
[0] == '_' &&
228 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
231 cp
= demangled
= xmalloc(strlen(mangled
) + 2);
233 if (mangled
[1] == 'i')
234 *cp
++ = '-'; /* for instance method */
236 *cp
++ = '+'; /* for class method */
238 *cp
++ = '['; /* opening left brace */
239 strcpy(cp
, mangled
+3); /* Tack on the rest of the mangled name. */
241 while (*cp
&& *cp
== '_')
242 cp
++; /* Skip any initial underbars in class
245 cp
= strchr(cp
, '_');
246 if (!cp
) /* Find first non-initial underbar. */
248 xfree(demangled
); /* not mangled name */
251 if (cp
[1] == '_') /* Easy case: no category name. */
253 *cp
++ = ' '; /* Replace two '_' with one ' '. */
254 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
258 *cp
++ = '('; /* Less easy case: category name. */
259 cp
= strchr(cp
, '_');
262 xfree(demangled
); /* not mangled name */
266 *cp
++ = ' '; /* Overwriting 1st char of method name... */
267 strcpy(cp
, mangled
+ (cp
- demangled
)); /* Get it back. */
270 while (*cp
&& *cp
== '_')
271 cp
++; /* Skip any initial underbars in
276 *cp
= ':'; /* Replace remaining '_' with ':'. */
278 *cp
++ = ']'; /* closing right brace */
279 *cp
++ = 0; /* string terminator */
283 return NULL
; /* Not an objc mangled name. */
286 /* Determine if we are currently in the Objective-C dispatch function.
287 If so, get the address of the method function that the dispatcher
288 would call and use that as the function to step into instead. Also
289 skip over the trampoline for the function (if any). This is better
290 for the user since they are only interested in stepping into the
291 method function anyway. */
293 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
295 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
296 CORE_ADDR real_stop_pc
;
297 CORE_ADDR method_stop_pc
;
299 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
301 if (real_stop_pc
!= 0)
302 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
304 find_objc_msgcall (stop_pc
, &method_stop_pc
);
308 real_stop_pc
= gdbarch_skip_trampoline_code
309 (gdbarch
, frame
, method_stop_pc
);
310 if (real_stop_pc
== 0)
311 real_stop_pc
= method_stop_pc
;
318 /* Table mapping opcodes into strings for printing operators
319 and precedences of the operators. */
321 static const struct op_print objc_op_print_tab
[] =
323 {",", BINOP_COMMA
, PREC_COMMA
, 0},
324 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
325 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
326 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
327 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
328 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
329 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
330 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
331 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
332 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
333 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
334 {">", BINOP_GTR
, PREC_ORDER
, 0},
335 {"<", BINOP_LESS
, PREC_ORDER
, 0},
336 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
337 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
338 {"+", BINOP_ADD
, PREC_ADD
, 0},
339 {"-", BINOP_SUB
, PREC_ADD
, 0},
340 {"*", BINOP_MUL
, PREC_MUL
, 0},
341 {"/", BINOP_DIV
, PREC_MUL
, 0},
342 {"%", BINOP_REM
, PREC_MUL
, 0},
343 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
344 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
345 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
346 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
347 {"*", UNOP_IND
, PREC_PREFIX
, 0},
348 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
349 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
350 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
351 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
352 {NULL
, OP_NULL
, PREC_NULL
, 0}
355 const struct language_defn objc_language_defn
= {
356 "objective-c", /* Language name */
362 &exp_descriptor_standard
,
366 c_printchar
, /* Print a character constant */
367 c_printstr
, /* Function to print string constant */
369 c_print_type
, /* Print a type using appropriate syntax */
370 c_print_typedef
, /* Print a typedef using appropriate syntax */
371 c_val_print
, /* Print a value using appropriate syntax */
372 c_value_print
, /* Print a top-level value */
373 default_read_var_value
, /* la_read_var_value */
374 objc_skip_trampoline
, /* Language specific skip_trampoline */
375 "self", /* name_of_this */
376 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
377 basic_lookup_transparent_type
,/* lookup_transparent_type */
378 objc_demangle
, /* Language specific symbol demangler */
379 NULL
, /* Language specific
380 class_name_from_physname */
381 objc_op_print_tab
, /* Expression operators for printing */
382 1, /* C-style arrays */
383 0, /* String lower bound */
384 default_word_break_characters
,
385 default_make_symbol_completion_list
,
386 c_language_arch_info
,
387 default_print_array_index
,
388 default_pass_by_reference
,
390 NULL
, /* la_get_symbol_name_cmp */
391 iterate_over_symbols
,
397 * Following functions help construct Objective-C message calls.
400 struct selname
/* For parsing Objective-C. */
402 struct selname
*next
;
407 static int msglist_len
;
408 static struct selname
*selname_chain
;
409 static char *msglist_sel
;
414 struct selname
*new =
415 (struct selname
*) xmalloc (sizeof (struct selname
));
417 new->next
= selname_chain
;
418 new->msglist_len
= msglist_len
;
419 new->msglist_sel
= msglist_sel
;
421 msglist_sel
= (char *)xmalloc(1);
427 add_msglist(struct stoken
*str
, int addcolon
)
433 if (str
== 0) /* Unnamed arg, or... */
435 if (addcolon
== 0) /* variable number of args. */
448 len
= plen
+ strlen(msglist_sel
) + 2;
449 s
= (char *)xmalloc(len
);
450 strcpy(s
, msglist_sel
);
467 int val
= msglist_len
;
468 struct selname
*sel
= selname_chain
;
469 char *p
= msglist_sel
;
472 selname_chain
= sel
->next
;
473 msglist_len
= sel
->msglist_len
;
474 msglist_sel
= sel
->msglist_sel
;
475 selid
= lookup_child_selector (parse_gdbarch
, p
);
477 error (_("Can't find selector \"%s\""), p
);
478 write_exp_elt_longcst (selid
);
480 write_exp_elt_longcst (val
); /* Number of args */
487 * Function: specialcmp (const char *a, const char *b)
489 * Special strcmp: treats ']' and ' ' as end-of-string.
490 * Used for qsorting lists of objc methods (either by class or selector).
494 specialcmp (const char *a
, const char *b
)
496 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
502 if (*a
&& *a
!= ' ' && *a
!= ']')
503 return 1; /* a is longer therefore greater. */
504 if (*b
&& *b
!= ' ' && *b
!= ']')
505 return -1; /* a is shorter therefore lesser. */
506 return 0; /* a and b are identical. */
510 * Function: compare_selectors (const void *, const void *)
512 * Comparison function for use with qsort. Arguments are symbols or
513 * msymbols Compares selector part of objc method name alphabetically.
517 compare_selectors (const void *a
, const void *b
)
519 const char *aname
, *bname
;
521 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
522 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
523 if (aname
== NULL
|| bname
== NULL
)
524 error (_("internal: compare_selectors(1)"));
526 aname
= strchr(aname
, ' ');
527 bname
= strchr(bname
, ' ');
528 if (aname
== NULL
|| bname
== NULL
)
529 error (_("internal: compare_selectors(2)"));
531 return specialcmp (aname
+1, bname
+1);
535 * Function: selectors_info (regexp, from_tty)
537 * Implements the "Info selectors" command. Takes an optional regexp
538 * arg. Lists all objective c selectors that match the regexp. Works
539 * by grepping thru all symbols for objective c methods. Output list
540 * is sorted and uniqued.
544 selectors_info (char *regexp
, int from_tty
)
546 struct objfile
*objfile
;
547 struct minimal_symbol
*msymbol
;
555 struct symbol
**sym_arr
;
559 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
562 if (*regexp
== '+' || *regexp
== '-')
563 { /* User wants only class methods or only instance methods. */
564 plusminus
= *regexp
++;
565 while (*regexp
== ' ' || *regexp
== '\t')
569 strcpy(myregexp
, ".*]");
572 /* Allow a few extra bytes because of the strcat below. */
573 if (sizeof (myregexp
) < strlen (regexp
) + 4)
574 error (_("Regexp is too long: %s"), regexp
);
575 strcpy(myregexp
, regexp
);
576 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
577 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
579 strcat(myregexp
, ".*]");
585 val
= re_comp (myregexp
);
587 error (_("Invalid regexp (%s): %s"), val
, regexp
);
590 /* First time thru is JUST to get max length and count. */
591 ALL_MSYMBOLS (objfile
, msymbol
)
594 name
= SYMBOL_NATURAL_NAME (msymbol
);
596 && (name
[0] == '-' || name
[0] == '+')
597 && name
[1] == '[') /* Got a method name. */
599 /* Filter for class/instance methods. */
600 if (plusminus
&& name
[0] != plusminus
)
602 /* Find selector part. */
603 name
= (char *) strchr (name
+2, ' ');
606 complaint (&symfile_complaints
,
607 _("Bad method name '%s'"),
608 SYMBOL_NATURAL_NAME (msymbol
));
611 if (regexp
== NULL
|| re_exec(++name
) != 0)
613 const char *mystart
= name
;
614 const char *myend
= strchr (mystart
, ']');
616 if (myend
&& (myend
- mystart
> maxlen
))
617 maxlen
= myend
- mystart
; /* Get longest selector. */
624 printf_filtered (_("Selectors matching \"%s\":\n\n"),
625 regexp
? regexp
: "*");
627 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
629 ALL_MSYMBOLS (objfile
, msymbol
)
632 name
= SYMBOL_NATURAL_NAME (msymbol
);
634 (name
[0] == '-' || name
[0] == '+') &&
635 name
[1] == '[') /* Got a method name. */
637 /* Filter for class/instance methods. */
638 if (plusminus
&& name
[0] != plusminus
)
640 /* Find selector part. */
641 name
= (char *) strchr(name
+2, ' ');
642 if (regexp
== NULL
|| re_exec(++name
) != 0)
643 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
647 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
649 /* Prevent compare on first iteration. */
651 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
656 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
657 name
= strchr (name
, ' ') + 1;
658 if (p
[0] && specialcmp(name
, p
) == 0)
659 continue; /* Seen this one already (not unique). */
661 /* Copy selector part. */
662 while (*name
&& *name
!= ']')
665 /* Print in columns. */
666 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
671 printf_filtered (_("No selectors matching \"%s\"\n"),
672 regexp
? regexp
: "*");
676 * Function: compare_classes (const void *, const void *)
678 * Comparison function for use with qsort. Arguments are symbols or
679 * msymbols Compares class part of objc method name alphabetically.
683 compare_classes (const void *a
, const void *b
)
685 const char *aname
, *bname
;
687 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
688 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
689 if (aname
== NULL
|| bname
== NULL
)
690 error (_("internal: compare_classes(1)"));
692 return specialcmp (aname
+1, bname
+1);
696 * Function: classes_info(regexp, from_tty)
698 * Implements the "info classes" command for objective c classes.
699 * Lists all objective c classes that match the optional regexp.
700 * Works by grepping thru the list of objective c methods. List will
701 * be sorted and uniqued (since one class may have many methods).
702 * BUGS: will not list a class that has no methods.
706 classes_info (char *regexp
, int from_tty
)
708 struct objfile
*objfile
;
709 struct minimal_symbol
*msymbol
;
717 struct symbol
**sym_arr
;
720 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
723 /* Allow a few extra bytes because of the strcat below. */
724 if (sizeof (myregexp
) < strlen (regexp
) + 4)
725 error (_("Regexp is too long: %s"), regexp
);
726 strcpy(myregexp
, regexp
);
727 if (myregexp
[strlen(myregexp
) - 1] == '$')
728 /* In the method name, the end of the class name is marked by ' '. */
729 myregexp
[strlen(myregexp
) - 1] = ' ';
731 strcat(myregexp
, ".* ");
736 val
= re_comp (myregexp
);
738 error (_("Invalid regexp (%s): %s"), val
, regexp
);
741 /* First time thru is JUST to get max length and count. */
742 ALL_MSYMBOLS (objfile
, msymbol
)
745 name
= SYMBOL_NATURAL_NAME (msymbol
);
747 (name
[0] == '-' || name
[0] == '+') &&
748 name
[1] == '[') /* Got a method name. */
749 if (regexp
== NULL
|| re_exec(name
+2) != 0)
751 /* Compute length of classname part. */
752 const char *mystart
= name
+ 2;
753 const char *myend
= strchr (mystart
, ' ');
755 if (myend
&& (myend
- mystart
> maxlen
))
756 maxlen
= myend
- mystart
;
762 printf_filtered (_("Classes matching \"%s\":\n\n"),
763 regexp
? regexp
: "*");
764 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
766 ALL_MSYMBOLS (objfile
, msymbol
)
769 name
= SYMBOL_NATURAL_NAME (msymbol
);
771 (name
[0] == '-' || name
[0] == '+') &&
772 name
[1] == '[') /* Got a method name. */
773 if (regexp
== NULL
|| re_exec(name
+2) != 0)
774 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
777 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
779 /* Prevent compare on first iteration. */
781 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
786 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
788 if (p
[0] && specialcmp(name
, p
) == 0)
789 continue; /* Seen this one already (not unique). */
791 /* Copy class part of method name. */
792 while (*name
&& *name
!= ' ')
795 /* Print in columns. */
796 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
801 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
805 parse_selector (char *method
, char **selector
)
811 char *nselector
= NULL
;
813 gdb_assert (selector
!= NULL
);
817 s1
= skip_spaces (s1
);
823 s1
= skip_spaces (s1
);
830 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
832 else if (isspace (*s2
))
834 else if ((*s2
== '\0') || (*s2
== '\''))
842 s2
= skip_spaces (s2
);
847 s2
= skip_spaces (s2
);
850 if (selector
!= NULL
)
851 *selector
= nselector
;
857 parse_method (char *method
, char *type
, char **class,
858 char **category
, char **selector
)
866 char *ncategory
= NULL
;
867 char *nselector
= NULL
;
869 gdb_assert (type
!= NULL
);
870 gdb_assert (class != NULL
);
871 gdb_assert (category
!= NULL
);
872 gdb_assert (selector
!= NULL
);
876 s1
= skip_spaces (s1
);
882 s1
= skip_spaces (s1
);
884 if ((s1
[0] == '+') || (s1
[0] == '-'))
887 s1
= skip_spaces (s1
);
894 while (isalnum (*s1
) || (*s1
== '_'))
898 s2
= skip_spaces (s2
);
903 s2
= skip_spaces (s2
);
905 while (isalnum (*s2
) || (*s2
== '_'))
910 /* Truncate the class name now that we're not using the open paren. */
918 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
920 else if (isspace (*s2
))
931 s2
= skip_spaces (s2
);
937 s2
= skip_spaces (s2
);
944 if (category
!= NULL
)
945 *category
= ncategory
;
946 if (selector
!= NULL
)
947 *selector
= nselector
;
953 find_methods (char type
, const char *class, const char *category
,
954 const char *selector
,
955 VEC (const_char_ptr
) **symbol_names
)
957 struct objfile
*objfile
= NULL
;
959 const char *symname
= NULL
;
963 char *ncategory
= NULL
;
964 char *nselector
= NULL
;
966 static char *tmp
= NULL
;
967 static unsigned int tmplen
= 0;
969 gdb_assert (symbol_names
!= NULL
);
971 ALL_OBJFILES (objfile
)
973 unsigned int *objc_csym
;
974 struct minimal_symbol
*msymbol
= NULL
;
976 /* The objfile_csym variable counts the number of ObjC methods
977 that this objfile defines. We save that count as a private
978 objfile data. If we have already determined that this objfile
979 provides no ObjC methods, we can skip it entirely. */
981 unsigned int objfile_csym
= 0;
983 objc_csym
= objfile_data (objfile
, objc_objfile_data
);
984 if (objc_csym
!= NULL
&& *objc_csym
== 0)
985 /* There are no ObjC symbols in this objfile. Skip it entirely. */
988 ALL_OBJFILE_MSYMBOLS (objfile
, msymbol
)
992 /* Check the symbol name first as this can be done entirely without
993 sending any query to the target. */
994 symname
= SYMBOL_NATURAL_NAME (msymbol
);
998 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
999 /* Not a method name. */
1004 /* Now that thinks are a bit sane, clean up the symname. */
1005 while ((strlen (symname
) + 1) >= tmplen
)
1007 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1008 tmp
= xrealloc (tmp
, tmplen
);
1010 strcpy (tmp
, symname
);
1012 if (parse_method (tmp
, &ntype
, &nclass
,
1013 &ncategory
, &nselector
) == NULL
)
1016 if ((type
!= '\0') && (ntype
!= type
))
1020 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1023 if ((category
!= NULL
) &&
1024 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1027 if ((selector
!= NULL
) &&
1028 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1031 VEC_safe_push (const_char_ptr
, *symbol_names
, symname
);
1034 if (objc_csym
== NULL
)
1036 objc_csym
= obstack_alloc (&objfile
->objfile_obstack
,
1037 sizeof (*objc_csym
));
1038 *objc_csym
= objfile_csym
;
1039 set_objfile_data (objfile
, objc_objfile_data
, objc_csym
);
1042 /* Count of ObjC methods in this objfile should be constant. */
1043 gdb_assert (*objc_csym
== objfile_csym
);
1047 /* Uniquify a VEC of strings. */
1050 uniquify_strings (VEC (const_char_ptr
) **strings
)
1053 const char *elem
, *last
= NULL
;
1056 qsort (VEC_address (const_char_ptr
, *strings
),
1057 VEC_length (const_char_ptr
, *strings
),
1058 sizeof (const_char_ptr
),
1061 for (ix
= 0; VEC_iterate (const_char_ptr
, *strings
, ix
, elem
); ++ix
)
1063 if (last
== NULL
|| strcmp (last
, elem
) != 0)
1066 VEC_replace (const_char_ptr
, *strings
, out
, elem
);
1071 VEC_truncate (const_char_ptr
, *strings
, out
);
1075 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1077 * Input: a string representing a selector
1078 * a pointer to an array of symbol pointers
1079 * possibly a pointer to a symbol found by the caller.
1081 * Output: number of methods that implement that selector. Side
1082 * effects: The array of symbol pointers is filled with matching syms.
1084 * By analogy with function "find_methods" (symtab.c), builds a list
1085 * of symbols matching the ambiguous input, so that "decode_line_2"
1086 * (symtab.c) can list them and ask the user to choose one or more.
1087 * In this case the matches are objective c methods
1088 * ("implementations") matching an objective c selector.
1090 * Note that it is possible for a normal (c-style) function to have
1091 * the same name as an objective c selector. To prevent the selector
1092 * from eclipsing the function, we allow the caller (decode_line_1) to
1093 * search for such a function first, and if it finds one, pass it in
1094 * to us. We will then integrate it into the list. We also search
1095 * for one here, among the minsyms.
1097 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1098 * into two parts: debuggable (struct symbol) syms, and
1099 * non_debuggable (struct minimal_symbol) syms. The debuggable
1100 * ones will come first, before NUM_DEBUGGABLE (which will thus
1101 * be the index of the first non-debuggable one).
1105 find_imps (const char *method
, VEC (const_char_ptr
) **symbol_names
)
1109 char *category
= NULL
;
1110 char *selector
= NULL
;
1115 int selector_case
= 0;
1117 gdb_assert (symbol_names
!= NULL
);
1119 buf
= (char *) alloca (strlen (method
) + 1);
1120 strcpy (buf
, method
);
1121 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1125 strcpy (buf
, method
);
1126 tmp
= parse_selector (buf
, &selector
);
1134 find_methods (type
, class, category
, selector
, symbol_names
);
1136 /* If we hit the "selector" case, and we found some methods, then
1137 add the selector itself as a symbol, if it exists. */
1138 if (selector_case
&& !VEC_empty (const_char_ptr
, *symbol_names
))
1140 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
, 0);
1143 VEC_safe_push (const_char_ptr
, *symbol_names
,
1144 SYMBOL_NATURAL_NAME (sym
));
1147 struct minimal_symbol
*msym
= lookup_minimal_symbol (selector
, 0, 0);
1150 VEC_safe_push (const_char_ptr
, *symbol_names
,
1151 SYMBOL_NATURAL_NAME (msym
));
1155 uniquify_strings (symbol_names
);
1157 return method
+ (tmp
- buf
);
1161 print_object_command (char *args
, int from_tty
)
1163 struct value
*object
, *function
, *description
;
1164 CORE_ADDR string_addr
, object_addr
;
1168 if (!args
|| !*args
)
1170 "The 'print-object' command requires an argument (an Objective-C object)");
1173 struct expression
*expr
= parse_expression (args
);
1174 struct cleanup
*old_chain
=
1175 make_cleanup (free_current_contents
, &expr
);
1178 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1179 expr
, &pc
, EVAL_NORMAL
);
1180 do_cleanups (old_chain
);
1183 /* Validate the address for sanity. */
1184 object_addr
= value_as_long (object
);
1185 read_memory (object_addr
, &c
, 1);
1187 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1188 if (function
== NULL
)
1189 error (_("Unable to locate _NSPrintForDebugger in child process"));
1191 description
= call_function_by_hand (function
, 1, &object
);
1193 string_addr
= value_as_long (description
);
1194 if (string_addr
== 0)
1195 error (_("object returns null description"));
1197 read_memory (string_addr
+ i
++, &c
, 1);
1200 { /* Read and print characters up to EOS. */
1202 printf_filtered ("%c", c
);
1203 read_memory (string_addr
+ i
++, &c
, 1);
1206 printf_filtered(_("<object returns empty description>"));
1207 printf_filtered ("\n");
1210 /* The data structure 'methcalls' is used to detect method calls (thru
1211 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1212 * and ultimately find the method being called.
1215 struct objc_methcall
{
1217 /* Return instance method to be called. */
1218 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1219 /* Start of pc range corresponding to method invocation. */
1221 /* End of pc range corresponding to method invocation. */
1225 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1226 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1227 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1228 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1230 static struct objc_methcall methcalls
[] = {
1231 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1232 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1233 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1234 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1235 { "_objc_getClass", NULL
, 0, 0},
1236 { "_objc_getMetaClass", NULL
, 0, 0}
1239 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1241 /* The following function, "find_objc_msgsend", fills in the data
1242 * structure "objc_msgs" by finding the addresses of each of the
1243 * (currently four) functions that it holds (of which objc_msgSend is
1244 * the first). This must be called each time symbols are loaded, in
1245 * case the functions have moved for some reason.
1249 find_objc_msgsend (void)
1253 for (i
= 0; i
< nmethcalls
; i
++)
1255 struct minimal_symbol
*func
;
1257 /* Try both with and without underscore. */
1258 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1259 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1261 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1265 methcalls
[i
].begin
= 0;
1266 methcalls
[i
].end
= 0;
1270 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1272 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1273 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
1277 /* find_objc_msgcall (replaces pc_off_limits)
1279 * ALL that this function now does is to determine whether the input
1280 * address ("pc") is the address of one of the Objective-C message
1281 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1282 * if so, it returns the address of the method that will be called.
1284 * The old function "pc_off_limits" used to do a lot of other things
1285 * in addition, such as detecting shared library jump stubs and
1286 * returning the address of the shlib function that would be called.
1287 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1288 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1289 * dependent modules.
1292 struct objc_submethod_helper_data
{
1293 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1299 find_objc_msgcall_submethod_helper (void * arg
)
1301 struct objc_submethod_helper_data
*s
=
1302 (struct objc_submethod_helper_data
*) arg
;
1304 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1311 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1315 struct objc_submethod_helper_data s
;
1321 if (catch_errors (find_objc_msgcall_submethod_helper
,
1323 "Unable to determine target of "
1324 "Objective-C method call (ignoring):\n",
1325 RETURN_MASK_ALL
) == 0)
1332 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1336 find_objc_msgsend ();
1342 for (i
= 0; i
< nmethcalls
; i
++)
1343 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1345 if (methcalls
[i
].stop_at
!= NULL
)
1346 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1355 /* -Wmissing-prototypes */
1356 extern initialize_file_ftype _initialize_objc_language
;
1359 _initialize_objc_language (void)
1361 add_language (&objc_language_defn
);
1362 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1363 _("All Objective-C selectors, or those matching REGEXP."));
1364 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1365 _("All Objective-C classes, or those matching REGEXP."));
1366 add_com ("print-object", class_vars
, print_object_command
,
1367 _("Ask an Objective-C object to print itself."));
1368 add_com_alias ("po", "print-object", class_vars
, 1);
1372 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1373 struct objc_method
*method
)
1375 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1377 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1378 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1379 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1382 static unsigned long
1383 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1385 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1387 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1391 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1392 unsigned long num
, struct objc_method
*method
)
1394 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1395 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1399 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1400 struct objc_object
*object
)
1402 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1404 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1408 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1409 struct objc_super
*super
)
1411 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1413 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1414 super
->class = read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1418 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1419 struct objc_class
*class)
1421 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1423 class->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1424 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1425 class->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1426 class->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1427 class->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1428 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1430 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1431 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1432 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1433 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1437 find_implementation_from_class (struct gdbarch
*gdbarch
,
1438 CORE_ADDR
class, CORE_ADDR sel
)
1440 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1441 CORE_ADDR subclass
= class;
1443 while (subclass
!= 0)
1446 struct objc_class class_str
;
1447 unsigned mlistnum
= 0;
1449 read_objc_class (gdbarch
, subclass
, &class_str
);
1454 unsigned long nmethods
;
1457 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1463 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1465 for (i
= 0; i
< nmethods
; i
++)
1467 struct objc_method meth_str
;
1469 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1472 "checking method 0x%lx against selector 0x%lx\n",
1473 meth_str
.name
, sel
);
1476 if (meth_str
.name
== sel
)
1477 /* FIXME: hppa arch was doing a pointer dereference
1478 here. There needs to be a better way to do that. */
1479 return meth_str
.imp
;
1483 subclass
= class_str
.super_class
;
1490 find_implementation (struct gdbarch
*gdbarch
,
1491 CORE_ADDR object
, CORE_ADDR sel
)
1493 struct objc_object ostr
;
1497 read_objc_object (gdbarch
, object
, &ostr
);
1501 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1505 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1507 struct frame_info
*frame
= get_current_frame ();
1508 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1509 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1515 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1516 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1518 res
= find_implementation (gdbarch
, object
, sel
);
1527 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1529 struct frame_info
*frame
= get_current_frame ();
1530 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1531 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1537 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1538 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1540 res
= find_implementation (gdbarch
, object
, sel
);
1549 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1551 struct frame_info
*frame
= get_current_frame ();
1552 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1553 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1555 struct objc_super sstr
;
1561 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1562 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1564 read_objc_super (gdbarch
, super
, &sstr
);
1565 if (sstr
.class == 0)
1568 res
= find_implementation_from_class (gdbarch
, sstr
.class, sel
);
1577 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1579 struct frame_info
*frame
= get_current_frame ();
1580 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1581 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1583 struct objc_super sstr
;
1589 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1590 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1592 read_objc_super (gdbarch
, super
, &sstr
);
1593 if (sstr
.class == 0)
1596 res
= find_implementation_from_class (gdbarch
, sstr
.class, sel
);
1604 /* Provide a prototype to silence -Wmissing-prototypes. */
1605 extern initialize_file_ftype _initialize_objc_lang
;
1608 _initialize_objc_lang (void)
1610 objc_objfile_data
= register_objfile_data ();