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"
31 #include "objc-lang.h"
32 #include "exceptions.h"
33 #include "complaints.h"
37 #include "gdb_string.h" /* for strchr */
38 #include "target.h" /* for target_has_execution */
42 #include "gdb_regex.h"
47 #include "gdb_assert.h"
48 #include "cli/cli-utils.h"
58 CORE_ADDR super_class
;
80 static const struct objfile_data
*objc_objfile_data
;
82 /* Lookup a structure type named "struct NAME", visible in lexical
83 block BLOCK. If NOERR is nonzero, return zero if NAME is not
87 lookup_struct_typedef (char *name
, const struct block
*block
, int noerr
)
91 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
98 error (_("No struct type named %s."), name
);
100 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
105 error (_("This context has class, union or enum %s, not a struct."),
112 lookup_objc_class (struct gdbarch
*gdbarch
, char *classname
)
114 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
115 struct value
* function
, *classval
;
117 if (! target_has_execution
)
119 /* Can't call into inferior to lookup class. */
123 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
124 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
125 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
126 function
= find_function_in_inferior("objc_lookup_class", NULL
);
129 complaint (&symfile_complaints
,
130 _("no way to lookup Objective-C classes"));
134 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
135 classval
= value_coerce_array (classval
);
136 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
141 lookup_child_selector (struct gdbarch
*gdbarch
, char *selname
)
143 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
144 struct value
* function
, *selstring
;
146 if (! target_has_execution
)
148 /* Can't call into inferior to lookup selector. */
152 if (lookup_minimal_symbol("sel_getUid", 0, 0))
153 function
= find_function_in_inferior("sel_getUid", NULL
);
154 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
155 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
158 complaint (&symfile_complaints
,
159 _("no way to lookup Objective-C selectors"));
163 selstring
= value_coerce_array (value_string (selname
,
164 strlen (selname
) + 1,
166 return value_as_long (call_function_by_hand (function
, 1, &selstring
));
170 value_nsstring (struct gdbarch
*gdbarch
, char *ptr
, int len
)
172 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
173 struct value
*stringValue
[3];
174 struct value
*function
, *nsstringValue
;
178 if (!target_has_execution
)
179 return 0; /* Can't call into inferior to create NSString. */
181 stringValue
[2] = value_string(ptr
, len
, char_type
);
182 stringValue
[2] = value_coerce_array(stringValue
[2]);
183 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
184 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
186 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
187 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
189 else if (lookup_minimal_symbol("istr", 0, 0))
191 function
= find_function_in_inferior("istr", NULL
);
192 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
194 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
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
, 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
= 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 /* Determine if we are currently in the Objective-C dispatch function.
288 If so, get the address of the method function that the dispatcher
289 would call and use that as the function to step into instead. Also
290 skip over the trampoline for the function (if any). This is better
291 for the user since they are only interested in stepping into the
292 method function anyway. */
294 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
296 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
297 CORE_ADDR real_stop_pc
;
298 CORE_ADDR method_stop_pc
;
300 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
302 if (real_stop_pc
!= 0)
303 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
305 find_objc_msgcall (stop_pc
, &method_stop_pc
);
309 real_stop_pc
= gdbarch_skip_trampoline_code
310 (gdbarch
, frame
, method_stop_pc
);
311 if (real_stop_pc
== 0)
312 real_stop_pc
= method_stop_pc
;
319 /* Table mapping opcodes into strings for printing operators
320 and precedences of the operators. */
322 static const struct op_print objc_op_print_tab
[] =
324 {",", BINOP_COMMA
, PREC_COMMA
, 0},
325 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
326 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
327 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
328 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
329 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
330 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
331 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
332 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
333 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
334 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
335 {">", BINOP_GTR
, PREC_ORDER
, 0},
336 {"<", BINOP_LESS
, PREC_ORDER
, 0},
337 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
338 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
339 {"+", BINOP_ADD
, PREC_ADD
, 0},
340 {"-", BINOP_SUB
, PREC_ADD
, 0},
341 {"*", BINOP_MUL
, PREC_MUL
, 0},
342 {"/", BINOP_DIV
, PREC_MUL
, 0},
343 {"%", BINOP_REM
, PREC_MUL
, 0},
344 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
345 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
346 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
347 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
348 {"*", UNOP_IND
, PREC_PREFIX
, 0},
349 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
350 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
351 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
352 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
353 {NULL
, OP_NULL
, PREC_NULL
, 0}
356 const struct language_defn objc_language_defn
= {
357 "objective-c", /* Language name */
364 &exp_descriptor_standard
,
368 c_printchar
, /* Print a character constant */
369 c_printstr
, /* Function to print string constant */
371 c_print_type
, /* Print a type using appropriate syntax */
372 c_print_typedef
, /* Print a typedef using appropriate syntax */
373 c_val_print
, /* Print a value using appropriate syntax */
374 c_value_print
, /* Print a top-level value */
375 default_read_var_value
, /* la_read_var_value */
376 objc_skip_trampoline
, /* Language specific skip_trampoline */
377 "self", /* name_of_this */
378 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
379 basic_lookup_transparent_type
,/* lookup_transparent_type */
380 objc_demangle
, /* Language specific symbol demangler */
381 NULL
, /* Language specific
382 class_name_from_physname */
383 objc_op_print_tab
, /* Expression operators for printing */
384 1, /* C-style arrays */
385 0, /* String lower bound */
386 default_word_break_characters
,
387 default_make_symbol_completion_list
,
388 c_language_arch_info
,
389 default_print_array_index
,
390 default_pass_by_reference
,
392 NULL
, /* la_get_symbol_name_cmp */
393 iterate_over_symbols
,
400 * Following functions help construct Objective-C message calls.
403 struct selname
/* For parsing Objective-C. */
405 struct selname
*next
;
410 static int msglist_len
;
411 static struct selname
*selname_chain
;
412 static char *msglist_sel
;
417 struct selname
*new =
418 (struct selname
*) xmalloc (sizeof (struct selname
));
420 new->next
= selname_chain
;
421 new->msglist_len
= msglist_len
;
422 new->msglist_sel
= msglist_sel
;
424 msglist_sel
= (char *)xmalloc(1);
430 add_msglist(struct stoken
*str
, int addcolon
)
436 if (str
== 0) /* Unnamed arg, or... */
438 if (addcolon
== 0) /* variable number of args. */
451 len
= plen
+ strlen(msglist_sel
) + 2;
452 s
= (char *)xmalloc(len
);
453 strcpy(s
, msglist_sel
);
470 int val
= msglist_len
;
471 struct selname
*sel
= selname_chain
;
472 char *p
= msglist_sel
;
475 selname_chain
= sel
->next
;
476 msglist_len
= sel
->msglist_len
;
477 msglist_sel
= sel
->msglist_sel
;
478 selid
= lookup_child_selector (parse_gdbarch
, p
);
480 error (_("Can't find selector \"%s\""), p
);
481 write_exp_elt_longcst (selid
);
483 write_exp_elt_longcst (val
); /* Number of args */
490 * Function: specialcmp (const char *a, const char *b)
492 * Special strcmp: treats ']' and ' ' as end-of-string.
493 * Used for qsorting lists of objc methods (either by class or selector).
497 specialcmp (const char *a
, const char *b
)
499 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
505 if (*a
&& *a
!= ' ' && *a
!= ']')
506 return 1; /* a is longer therefore greater. */
507 if (*b
&& *b
!= ' ' && *b
!= ']')
508 return -1; /* a is shorter therefore lesser. */
509 return 0; /* a and b are identical. */
513 * Function: compare_selectors (const void *, const void *)
515 * Comparison function for use with qsort. Arguments are symbols or
516 * msymbols Compares selector part of objc method name alphabetically.
520 compare_selectors (const void *a
, const void *b
)
522 const char *aname
, *bname
;
524 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
525 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
526 if (aname
== NULL
|| bname
== NULL
)
527 error (_("internal: compare_selectors(1)"));
529 aname
= strchr(aname
, ' ');
530 bname
= strchr(bname
, ' ');
531 if (aname
== NULL
|| bname
== NULL
)
532 error (_("internal: compare_selectors(2)"));
534 return specialcmp (aname
+1, bname
+1);
538 * Function: selectors_info (regexp, from_tty)
540 * Implements the "Info selectors" command. Takes an optional regexp
541 * arg. Lists all objective c selectors that match the regexp. Works
542 * by grepping thru all symbols for objective c methods. Output list
543 * is sorted and uniqued.
547 selectors_info (char *regexp
, int from_tty
)
549 struct objfile
*objfile
;
550 struct minimal_symbol
*msymbol
;
558 struct symbol
**sym_arr
;
562 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
565 if (*regexp
== '+' || *regexp
== '-')
566 { /* User wants only class methods or only instance methods. */
567 plusminus
= *regexp
++;
568 while (*regexp
== ' ' || *regexp
== '\t')
572 strcpy(myregexp
, ".*]");
575 /* Allow a few extra bytes because of the strcat below. */
576 if (sizeof (myregexp
) < strlen (regexp
) + 4)
577 error (_("Regexp is too long: %s"), regexp
);
578 strcpy(myregexp
, regexp
);
579 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
580 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
582 strcat(myregexp
, ".*]");
588 val
= re_comp (myregexp
);
590 error (_("Invalid regexp (%s): %s"), val
, regexp
);
593 /* First time thru is JUST to get max length and count. */
594 ALL_MSYMBOLS (objfile
, msymbol
)
597 name
= SYMBOL_NATURAL_NAME (msymbol
);
599 && (name
[0] == '-' || name
[0] == '+')
600 && name
[1] == '[') /* Got a method name. */
602 /* Filter for class/instance methods. */
603 if (plusminus
&& name
[0] != plusminus
)
605 /* Find selector part. */
606 name
= (char *) strchr (name
+2, ' ');
609 complaint (&symfile_complaints
,
610 _("Bad method name '%s'"),
611 SYMBOL_NATURAL_NAME (msymbol
));
614 if (regexp
== NULL
|| re_exec(++name
) != 0)
616 const char *mystart
= name
;
617 const char *myend
= strchr (mystart
, ']');
619 if (myend
&& (myend
- mystart
> maxlen
))
620 maxlen
= myend
- mystart
; /* Get longest selector. */
627 printf_filtered (_("Selectors matching \"%s\":\n\n"),
628 regexp
? regexp
: "*");
630 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
632 ALL_MSYMBOLS (objfile
, msymbol
)
635 name
= SYMBOL_NATURAL_NAME (msymbol
);
637 (name
[0] == '-' || name
[0] == '+') &&
638 name
[1] == '[') /* Got a method name. */
640 /* Filter for class/instance methods. */
641 if (plusminus
&& name
[0] != plusminus
)
643 /* Find selector part. */
644 name
= (char *) strchr(name
+2, ' ');
645 if (regexp
== NULL
|| re_exec(++name
) != 0)
646 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
650 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
652 /* Prevent compare on first iteration. */
654 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
659 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
660 name
= strchr (name
, ' ') + 1;
661 if (p
[0] && specialcmp(name
, p
) == 0)
662 continue; /* Seen this one already (not unique). */
664 /* Copy selector part. */
665 while (*name
&& *name
!= ']')
668 /* Print in columns. */
669 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
674 printf_filtered (_("No selectors matching \"%s\"\n"),
675 regexp
? regexp
: "*");
679 * Function: compare_classes (const void *, const void *)
681 * Comparison function for use with qsort. Arguments are symbols or
682 * msymbols Compares class part of objc method name alphabetically.
686 compare_classes (const void *a
, const void *b
)
688 const char *aname
, *bname
;
690 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
691 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
692 if (aname
== NULL
|| bname
== NULL
)
693 error (_("internal: compare_classes(1)"));
695 return specialcmp (aname
+1, bname
+1);
699 * Function: classes_info(regexp, from_tty)
701 * Implements the "info classes" command for objective c classes.
702 * Lists all objective c classes that match the optional regexp.
703 * Works by grepping thru the list of objective c methods. List will
704 * be sorted and uniqued (since one class may have many methods).
705 * BUGS: will not list a class that has no methods.
709 classes_info (char *regexp
, int from_tty
)
711 struct objfile
*objfile
;
712 struct minimal_symbol
*msymbol
;
720 struct symbol
**sym_arr
;
723 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
726 /* Allow a few extra bytes because of the strcat below. */
727 if (sizeof (myregexp
) < strlen (regexp
) + 4)
728 error (_("Regexp is too long: %s"), regexp
);
729 strcpy(myregexp
, regexp
);
730 if (myregexp
[strlen(myregexp
) - 1] == '$')
731 /* In the method name, the end of the class name is marked by ' '. */
732 myregexp
[strlen(myregexp
) - 1] = ' ';
734 strcat(myregexp
, ".* ");
739 val
= re_comp (myregexp
);
741 error (_("Invalid regexp (%s): %s"), val
, regexp
);
744 /* First time thru is JUST to get max length and count. */
745 ALL_MSYMBOLS (objfile
, msymbol
)
748 name
= SYMBOL_NATURAL_NAME (msymbol
);
750 (name
[0] == '-' || name
[0] == '+') &&
751 name
[1] == '[') /* Got a method name. */
752 if (regexp
== NULL
|| re_exec(name
+2) != 0)
754 /* Compute length of classname part. */
755 const char *mystart
= name
+ 2;
756 const char *myend
= strchr (mystart
, ' ');
758 if (myend
&& (myend
- mystart
> maxlen
))
759 maxlen
= myend
- mystart
;
765 printf_filtered (_("Classes matching \"%s\":\n\n"),
766 regexp
? regexp
: "*");
767 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
769 ALL_MSYMBOLS (objfile
, msymbol
)
772 name
= SYMBOL_NATURAL_NAME (msymbol
);
774 (name
[0] == '-' || name
[0] == '+') &&
775 name
[1] == '[') /* Got a method name. */
776 if (regexp
== NULL
|| re_exec(name
+2) != 0)
777 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
780 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
782 /* Prevent compare on first iteration. */
784 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
789 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
791 if (p
[0] && specialcmp(name
, p
) == 0)
792 continue; /* Seen this one already (not unique). */
794 /* Copy class part of method name. */
795 while (*name
&& *name
!= ' ')
798 /* Print in columns. */
799 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
804 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
808 parse_selector (char *method
, char **selector
)
814 char *nselector
= NULL
;
816 gdb_assert (selector
!= NULL
);
820 s1
= skip_spaces (s1
);
826 s1
= skip_spaces (s1
);
833 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
835 else if (isspace (*s2
))
837 else if ((*s2
== '\0') || (*s2
== '\''))
845 s2
= skip_spaces (s2
);
850 s2
= skip_spaces (s2
);
853 if (selector
!= NULL
)
854 *selector
= nselector
;
860 parse_method (char *method
, char *type
, char **class,
861 char **category
, char **selector
)
869 char *ncategory
= NULL
;
870 char *nselector
= NULL
;
872 gdb_assert (type
!= NULL
);
873 gdb_assert (class != NULL
);
874 gdb_assert (category
!= NULL
);
875 gdb_assert (selector
!= NULL
);
879 s1
= skip_spaces (s1
);
885 s1
= skip_spaces (s1
);
887 if ((s1
[0] == '+') || (s1
[0] == '-'))
890 s1
= skip_spaces (s1
);
897 while (isalnum (*s1
) || (*s1
== '_'))
901 s2
= skip_spaces (s2
);
906 s2
= skip_spaces (s2
);
908 while (isalnum (*s2
) || (*s2
== '_'))
913 /* Truncate the class name now that we're not using the open paren. */
921 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
923 else if (isspace (*s2
))
934 s2
= skip_spaces (s2
);
940 s2
= skip_spaces (s2
);
947 if (category
!= NULL
)
948 *category
= ncategory
;
949 if (selector
!= NULL
)
950 *selector
= nselector
;
956 find_methods (char type
, const char *class, const char *category
,
957 const char *selector
,
958 VEC (const_char_ptr
) **symbol_names
)
960 struct objfile
*objfile
= NULL
;
962 const char *symname
= NULL
;
966 char *ncategory
= NULL
;
967 char *nselector
= NULL
;
969 static char *tmp
= NULL
;
970 static unsigned int tmplen
= 0;
972 gdb_assert (symbol_names
!= NULL
);
974 ALL_OBJFILES (objfile
)
976 unsigned int *objc_csym
;
977 struct minimal_symbol
*msymbol
= NULL
;
979 /* The objfile_csym variable counts the number of ObjC methods
980 that this objfile defines. We save that count as a private
981 objfile data. If we have already determined that this objfile
982 provides no ObjC methods, we can skip it entirely. */
984 unsigned int objfile_csym
= 0;
986 objc_csym
= objfile_data (objfile
, objc_objfile_data
);
987 if (objc_csym
!= NULL
&& *objc_csym
== 0)
988 /* There are no ObjC symbols in this objfile. Skip it entirely. */
991 ALL_OBJFILE_MSYMBOLS (objfile
, msymbol
)
995 /* Check the symbol name first as this can be done entirely without
996 sending any query to the target. */
997 symname
= SYMBOL_NATURAL_NAME (msymbol
);
1001 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1002 /* Not a method name. */
1007 /* Now that thinks are a bit sane, clean up the symname. */
1008 while ((strlen (symname
) + 1) >= tmplen
)
1010 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1011 tmp
= xrealloc (tmp
, tmplen
);
1013 strcpy (tmp
, symname
);
1015 if (parse_method (tmp
, &ntype
, &nclass
,
1016 &ncategory
, &nselector
) == NULL
)
1019 if ((type
!= '\0') && (ntype
!= type
))
1023 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1026 if ((category
!= NULL
) &&
1027 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1030 if ((selector
!= NULL
) &&
1031 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1034 VEC_safe_push (const_char_ptr
, *symbol_names
, symname
);
1037 if (objc_csym
== NULL
)
1039 objc_csym
= obstack_alloc (&objfile
->objfile_obstack
,
1040 sizeof (*objc_csym
));
1041 *objc_csym
= objfile_csym
;
1042 set_objfile_data (objfile
, objc_objfile_data
, objc_csym
);
1045 /* Count of ObjC methods in this objfile should be constant. */
1046 gdb_assert (*objc_csym
== objfile_csym
);
1050 /* Uniquify a VEC of strings. */
1053 uniquify_strings (VEC (const_char_ptr
) **strings
)
1056 const char *elem
, *last
= NULL
;
1059 qsort (VEC_address (const_char_ptr
, *strings
),
1060 VEC_length (const_char_ptr
, *strings
),
1061 sizeof (const_char_ptr
),
1064 for (ix
= 0; VEC_iterate (const_char_ptr
, *strings
, ix
, elem
); ++ix
)
1066 if (last
== NULL
|| strcmp (last
, elem
) != 0)
1069 VEC_replace (const_char_ptr
, *strings
, out
, elem
);
1074 VEC_truncate (const_char_ptr
, *strings
, out
);
1078 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1080 * Input: a string representing a selector
1081 * a pointer to an array of symbol pointers
1082 * possibly a pointer to a symbol found by the caller.
1084 * Output: number of methods that implement that selector. Side
1085 * effects: The array of symbol pointers is filled with matching syms.
1087 * By analogy with function "find_methods" (symtab.c), builds a list
1088 * of symbols matching the ambiguous input, so that "decode_line_2"
1089 * (symtab.c) can list them and ask the user to choose one or more.
1090 * In this case the matches are objective c methods
1091 * ("implementations") matching an objective c selector.
1093 * Note that it is possible for a normal (c-style) function to have
1094 * the same name as an objective c selector. To prevent the selector
1095 * from eclipsing the function, we allow the caller (decode_line_1) to
1096 * search for such a function first, and if it finds one, pass it in
1097 * to us. We will then integrate it into the list. We also search
1098 * for one here, among the minsyms.
1100 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1101 * into two parts: debuggable (struct symbol) syms, and
1102 * non_debuggable (struct minimal_symbol) syms. The debuggable
1103 * ones will come first, before NUM_DEBUGGABLE (which will thus
1104 * be the index of the first non-debuggable one).
1108 find_imps (const char *method
, VEC (const_char_ptr
) **symbol_names
)
1112 char *category
= NULL
;
1113 char *selector
= NULL
;
1118 int selector_case
= 0;
1120 gdb_assert (symbol_names
!= NULL
);
1122 buf
= (char *) alloca (strlen (method
) + 1);
1123 strcpy (buf
, method
);
1124 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1128 strcpy (buf
, method
);
1129 tmp
= parse_selector (buf
, &selector
);
1137 find_methods (type
, class, category
, selector
, symbol_names
);
1139 /* If we hit the "selector" case, and we found some methods, then
1140 add the selector itself as a symbol, if it exists. */
1141 if (selector_case
&& !VEC_empty (const_char_ptr
, *symbol_names
))
1143 struct symbol
*sym
= lookup_symbol (selector
, NULL
, VAR_DOMAIN
, 0);
1146 VEC_safe_push (const_char_ptr
, *symbol_names
,
1147 SYMBOL_NATURAL_NAME (sym
));
1150 struct minimal_symbol
*msym
= lookup_minimal_symbol (selector
, 0, 0);
1153 VEC_safe_push (const_char_ptr
, *symbol_names
,
1154 SYMBOL_NATURAL_NAME (msym
));
1158 uniquify_strings (symbol_names
);
1160 return method
+ (tmp
- buf
);
1164 print_object_command (char *args
, int from_tty
)
1166 struct value
*object
, *function
, *description
;
1167 CORE_ADDR string_addr
, object_addr
;
1171 if (!args
|| !*args
)
1173 "The 'print-object' command requires an argument (an Objective-C object)");
1176 struct expression
*expr
= parse_expression (args
);
1177 struct cleanup
*old_chain
=
1178 make_cleanup (free_current_contents
, &expr
);
1181 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1182 expr
, &pc
, EVAL_NORMAL
);
1183 do_cleanups (old_chain
);
1186 /* Validate the address for sanity. */
1187 object_addr
= value_as_long (object
);
1188 read_memory (object_addr
, &c
, 1);
1190 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1191 if (function
== NULL
)
1192 error (_("Unable to locate _NSPrintForDebugger in child process"));
1194 description
= call_function_by_hand (function
, 1, &object
);
1196 string_addr
= value_as_long (description
);
1197 if (string_addr
== 0)
1198 error (_("object returns null description"));
1200 read_memory (string_addr
+ i
++, &c
, 1);
1203 { /* Read and print characters up to EOS. */
1205 printf_filtered ("%c", c
);
1206 read_memory (string_addr
+ i
++, &c
, 1);
1209 printf_filtered(_("<object returns empty description>"));
1210 printf_filtered ("\n");
1213 /* The data structure 'methcalls' is used to detect method calls (thru
1214 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1215 * and ultimately find the method being called.
1218 struct objc_methcall
{
1220 /* Return instance method to be called. */
1221 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1222 /* Start of pc range corresponding to method invocation. */
1224 /* End of pc range corresponding to method invocation. */
1228 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1229 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1230 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1231 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1233 static struct objc_methcall methcalls
[] = {
1234 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1235 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1236 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1237 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1238 { "_objc_getClass", NULL
, 0, 0},
1239 { "_objc_getMetaClass", NULL
, 0, 0}
1242 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1244 /* The following function, "find_objc_msgsend", fills in the data
1245 * structure "objc_msgs" by finding the addresses of each of the
1246 * (currently four) functions that it holds (of which objc_msgSend is
1247 * the first). This must be called each time symbols are loaded, in
1248 * case the functions have moved for some reason.
1252 find_objc_msgsend (void)
1256 for (i
= 0; i
< nmethcalls
; i
++)
1258 struct minimal_symbol
*func
;
1260 /* Try both with and without underscore. */
1261 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1262 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1264 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1268 methcalls
[i
].begin
= 0;
1269 methcalls
[i
].end
= 0;
1273 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1275 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1276 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
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.
1295 struct objc_submethod_helper_data
{
1296 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1302 find_objc_msgcall_submethod_helper (void * arg
)
1304 struct objc_submethod_helper_data
*s
=
1305 (struct objc_submethod_helper_data
*) arg
;
1307 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1314 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1318 struct objc_submethod_helper_data s
;
1324 if (catch_errors (find_objc_msgcall_submethod_helper
,
1326 "Unable to determine target of "
1327 "Objective-C method call (ignoring):\n",
1328 RETURN_MASK_ALL
) == 0)
1335 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1339 find_objc_msgsend ();
1345 for (i
= 0; i
< nmethcalls
; i
++)
1346 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1348 if (methcalls
[i
].stop_at
!= NULL
)
1349 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1358 /* -Wmissing-prototypes */
1359 extern initialize_file_ftype _initialize_objc_language
;
1362 _initialize_objc_language (void)
1364 add_language (&objc_language_defn
);
1365 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1366 _("All Objective-C selectors, or those matching REGEXP."));
1367 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1368 _("All Objective-C classes, or those matching REGEXP."));
1369 add_com ("print-object", class_vars
, print_object_command
,
1370 _("Ask an Objective-C object to print itself."));
1371 add_com_alias ("po", "print-object", class_vars
, 1);
1375 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1376 struct objc_method
*method
)
1378 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1380 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1381 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1382 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1385 static unsigned long
1386 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1388 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1390 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1394 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1395 unsigned long num
, struct objc_method
*method
)
1397 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1398 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1402 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1403 struct objc_object
*object
)
1405 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1407 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1411 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1412 struct objc_super
*super
)
1414 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1416 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1417 super
->class = read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1421 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1422 struct objc_class
*class)
1424 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1426 class->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1427 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1428 class->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1429 class->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1430 class->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1431 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1433 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1434 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1435 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1436 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1440 find_implementation_from_class (struct gdbarch
*gdbarch
,
1441 CORE_ADDR
class, CORE_ADDR sel
)
1443 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1444 CORE_ADDR subclass
= class;
1446 while (subclass
!= 0)
1449 struct objc_class class_str
;
1450 unsigned mlistnum
= 0;
1452 read_objc_class (gdbarch
, subclass
, &class_str
);
1457 unsigned long nmethods
;
1460 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1466 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1468 for (i
= 0; i
< nmethods
; i
++)
1470 struct objc_method meth_str
;
1472 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1475 "checking method 0x%lx against selector 0x%lx\n",
1476 meth_str
.name
, sel
);
1479 if (meth_str
.name
== sel
)
1480 /* FIXME: hppa arch was doing a pointer dereference
1481 here. There needs to be a better way to do that. */
1482 return meth_str
.imp
;
1486 subclass
= class_str
.super_class
;
1493 find_implementation (struct gdbarch
*gdbarch
,
1494 CORE_ADDR object
, CORE_ADDR sel
)
1496 struct objc_object ostr
;
1500 read_objc_object (gdbarch
, object
, &ostr
);
1504 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1508 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1510 struct frame_info
*frame
= get_current_frame ();
1511 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1512 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1518 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1519 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1521 res
= find_implementation (gdbarch
, object
, sel
);
1530 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1532 struct frame_info
*frame
= get_current_frame ();
1533 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1534 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1540 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1541 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1543 res
= find_implementation (gdbarch
, object
, sel
);
1552 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1554 struct frame_info
*frame
= get_current_frame ();
1555 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1556 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1558 struct objc_super sstr
;
1564 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1565 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1567 read_objc_super (gdbarch
, super
, &sstr
);
1568 if (sstr
.class == 0)
1571 res
= find_implementation_from_class (gdbarch
, sstr
.class, sel
);
1580 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1582 struct frame_info
*frame
= get_current_frame ();
1583 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1584 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1586 struct objc_super sstr
;
1592 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1593 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1595 read_objc_super (gdbarch
, super
, &sstr
);
1596 if (sstr
.class == 0)
1599 res
= find_implementation_from_class (gdbarch
, sstr
.class, sel
);
1607 /* Provide a prototype to silence -Wmissing-prototypes. */
1608 extern initialize_file_ftype _initialize_objc_lang
;
1611 _initialize_objc_lang (void)
1613 objc_objfile_data
= register_objfile_data ();