1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Apple Computer, Inc.
7 Written by Michael Snyder.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "expression.h"
28 #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"
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
, 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
, _("no way to lookup Objective-C classes"));
132 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
133 classval
= value_coerce_array (classval
);
134 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
139 lookup_child_selector (struct gdbarch
*gdbarch
, char *selname
)
141 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
142 struct value
* function
, *selstring
;
144 if (! target_has_execution
)
146 /* Can't call into inferior to lookup selector. */
150 if (lookup_minimal_symbol("sel_getUid", 0, 0))
151 function
= find_function_in_inferior("sel_getUid", NULL
);
152 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
153 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
156 complaint (&symfile_complaints
, _("no way to lookup Objective-C selectors"));
160 selstring
= value_coerce_array (value_string (selname
,
161 strlen (selname
) + 1, char_type
));
162 return value_as_long (call_function_by_hand (function
, 1, &selstring
));
166 value_nsstring (struct gdbarch
*gdbarch
, char *ptr
, int len
)
168 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
169 struct value
*stringValue
[3];
170 struct value
*function
, *nsstringValue
;
174 if (!target_has_execution
)
175 return 0; /* Can't call into inferior to create NSString. */
177 stringValue
[2] = value_string(ptr
, len
, char_type
);
178 stringValue
[2] = value_coerce_array(stringValue
[2]);
179 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
180 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
182 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
183 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
185 else if (lookup_minimal_symbol("istr", 0, 0))
187 function
= find_function_in_inferior("istr", NULL
);
188 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
190 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
193 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
194 type
= builtin_type (gdbarch
)->builtin_long
;
196 stringValue
[0] = value_from_longest
197 (type
, lookup_objc_class (gdbarch
, "NSString"));
198 stringValue
[1] = value_from_longest
199 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
200 nsstringValue
= call_function_by_hand(function
, 3, &stringValue
[0]);
203 error (_("NSString: internal error -- no way to create new NSString"));
205 sym
= lookup_struct_typedef("NSString", 0, 1);
207 sym
= lookup_struct_typedef("NXString", 0, 1);
209 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
211 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
213 deprecated_set_value_type (nsstringValue
, type
);
214 return nsstringValue
;
217 /* Objective-C name demangling. */
220 objc_demangle (const char *mangled
, int options
)
222 char *demangled
, *cp
;
224 if (mangled
[0] == '_' &&
225 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
228 cp
= demangled
= xmalloc(strlen(mangled
) + 2);
230 if (mangled
[1] == 'i')
231 *cp
++ = '-'; /* for instance method */
233 *cp
++ = '+'; /* for class method */
235 *cp
++ = '['; /* opening left brace */
236 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
238 while (*cp
&& *cp
== '_')
239 cp
++; /* skip any initial underbars in class name */
241 cp
= strchr(cp
, '_');
242 if (!cp
) /* find first non-initial underbar */
244 xfree(demangled
); /* not mangled name */
247 if (cp
[1] == '_') { /* easy case: no category name */
248 *cp
++ = ' '; /* replace two '_' with one ' ' */
249 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
252 *cp
++ = '('; /* less easy case: category name */
253 cp
= strchr(cp
, '_');
256 xfree(demangled
); /* not mangled name */
260 *cp
++ = ' '; /* overwriting 1st char of method name... */
261 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
264 while (*cp
&& *cp
== '_')
265 cp
++; /* skip any initial underbars in method name */
269 *cp
= ':'; /* replace remaining '_' with ':' */
271 *cp
++ = ']'; /* closing right brace */
272 *cp
++ = 0; /* string terminator */
276 return NULL
; /* Not an objc mangled name. */
279 /* Print the character C on STREAM as part of the contents of a
280 literal string whose delimiter is QUOTER. Note that that format
281 for printing characters and strings is language specific. */
284 objc_emit_char (int c
, struct type
*type
, struct ui_file
*stream
, int quoter
)
287 c
&= 0xFF; /* Avoid sign bit follies. */
289 if (PRINT_LITERAL_FORM (c
))
291 if (c
== '\\' || c
== quoter
)
293 fputs_filtered ("\\", stream
);
295 fprintf_filtered (stream
, "%c", c
);
302 fputs_filtered ("\\n", stream
);
305 fputs_filtered ("\\b", stream
);
308 fputs_filtered ("\\t", stream
);
311 fputs_filtered ("\\f", stream
);
314 fputs_filtered ("\\r", stream
);
317 fputs_filtered ("\\e", stream
);
320 fputs_filtered ("\\a", stream
);
323 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
330 objc_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
332 fputs_filtered ("'", stream
);
333 objc_emit_char (c
, type
, stream
, '\'');
334 fputs_filtered ("'", stream
);
337 /* Print the character string STRING, printing at most LENGTH
338 characters. Printing stops early if the number hits print_max;
339 repeat counts are printed as appropriate. Print ellipses at the
340 end if we had to stop before printing LENGTH characters, or if
344 objc_printstr (struct ui_file
*stream
, struct type
*type
,
345 const gdb_byte
*string
, unsigned int length
,
346 const char *encoding
, int force_ellipses
,
347 const struct value_print_options
*options
)
350 unsigned int things_printed
= 0;
353 int width
= TYPE_LENGTH (type
);
355 /* If the string was not truncated due to `set print elements', and
356 the last byte of it is a null, we don't print that, in
357 traditional C style. */
358 if ((!force_ellipses
) && length
> 0 && string
[length
-1] == '\0')
363 fputs_filtered ("\"\"", stream
);
367 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; ++i
)
369 /* Position of the character we are examining to see whether it
372 /* Number of repetitions we have detected so far. */
379 fputs_filtered (", ", stream
);
385 while (rep1
< length
&& string
[rep1
] == string
[i
])
391 if (reps
> options
->repeat_count_threshold
)
395 if (options
->inspect_it
)
396 fputs_filtered ("\\\", ", stream
);
398 fputs_filtered ("\", ", stream
);
401 objc_printchar (string
[i
], type
, stream
);
402 fprintf_filtered (stream
, " <repeats %u times>", reps
);
404 things_printed
+= options
->repeat_count_threshold
;
411 if (options
->inspect_it
)
412 fputs_filtered ("\\\"", stream
);
414 fputs_filtered ("\"", stream
);
417 objc_emit_char (string
[i
], type
, stream
, '"');
422 /* Terminate the quotes if necessary. */
425 if (options
->inspect_it
)
426 fputs_filtered ("\\\"", stream
);
428 fputs_filtered ("\"", stream
);
431 if (force_ellipses
|| i
< length
)
432 fputs_filtered ("...", stream
);
435 /* Determine if we are currently in the Objective-C dispatch function.
436 If so, get the address of the method function that the dispatcher
437 would call and use that as the function to step into instead. Also
438 skip over the trampoline for the function (if any). This is better
439 for the user since they are only interested in stepping into the
440 method function anyway. */
442 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
444 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
445 CORE_ADDR real_stop_pc
;
446 CORE_ADDR method_stop_pc
;
448 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
450 if (real_stop_pc
!= 0)
451 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
453 find_objc_msgcall (stop_pc
, &method_stop_pc
);
457 real_stop_pc
= gdbarch_skip_trampoline_code
458 (gdbarch
, frame
, method_stop_pc
);
459 if (real_stop_pc
== 0)
460 real_stop_pc
= method_stop_pc
;
467 /* Table mapping opcodes into strings for printing operators
468 and precedences of the operators. */
470 static const struct op_print objc_op_print_tab
[] =
472 {",", BINOP_COMMA
, PREC_COMMA
, 0},
473 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
474 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
475 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
476 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
477 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
478 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
479 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
480 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
481 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
482 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
483 {">", BINOP_GTR
, PREC_ORDER
, 0},
484 {"<", BINOP_LESS
, PREC_ORDER
, 0},
485 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
486 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
487 {"+", BINOP_ADD
, PREC_ADD
, 0},
488 {"-", BINOP_SUB
, PREC_ADD
, 0},
489 {"*", BINOP_MUL
, PREC_MUL
, 0},
490 {"/", BINOP_DIV
, PREC_MUL
, 0},
491 {"%", BINOP_REM
, PREC_MUL
, 0},
492 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
493 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
494 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
495 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
496 {"*", UNOP_IND
, PREC_PREFIX
, 0},
497 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
498 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
499 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
500 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
501 {NULL
, OP_NULL
, PREC_NULL
, 0}
504 const struct language_defn objc_language_defn
= {
505 "objective-c", /* Language name */
512 &exp_descriptor_standard
,
516 objc_printchar
, /* Print a character constant */
517 objc_printstr
, /* Function to print string constant */
519 c_print_type
, /* Print a type using appropriate syntax */
520 c_print_typedef
, /* Print a typedef using appropriate syntax */
521 c_val_print
, /* Print a value using appropriate syntax */
522 c_value_print
, /* Print a top-level value */
523 objc_skip_trampoline
, /* Language specific skip_trampoline */
524 "self", /* name_of_this */
525 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
526 basic_lookup_transparent_type
,/* lookup_transparent_type */
527 objc_demangle
, /* Language specific symbol demangler */
528 NULL
, /* Language specific class_name_from_physname */
529 objc_op_print_tab
, /* Expression operators for printing */
530 1, /* C-style arrays */
531 0, /* String lower bound */
532 default_word_break_characters
,
533 default_make_symbol_completion_list
,
534 c_language_arch_info
,
535 default_print_array_index
,
536 default_pass_by_reference
,
543 * Following functions help construct Objective-C message calls
546 struct selname
/* For parsing Objective-C. */
548 struct selname
*next
;
553 static int msglist_len
;
554 static struct selname
*selname_chain
;
555 static char *msglist_sel
;
560 struct selname
*new =
561 (struct selname
*) xmalloc (sizeof (struct selname
));
563 new->next
= selname_chain
;
564 new->msglist_len
= msglist_len
;
565 new->msglist_sel
= msglist_sel
;
567 msglist_sel
= (char *)xmalloc(1);
573 add_msglist(struct stoken
*str
, int addcolon
)
578 if (str
== 0) { /* Unnamed arg, or... */
579 if (addcolon
== 0) { /* variable number of args. */
589 len
= plen
+ strlen(msglist_sel
) + 2;
590 s
= (char *)xmalloc(len
);
591 strcpy(s
, msglist_sel
);
606 int val
= msglist_len
;
607 struct selname
*sel
= selname_chain
;
608 char *p
= msglist_sel
;
611 selname_chain
= sel
->next
;
612 msglist_len
= sel
->msglist_len
;
613 msglist_sel
= sel
->msglist_sel
;
614 selid
= lookup_child_selector (parse_gdbarch
, p
);
616 error (_("Can't find selector \"%s\""), p
);
617 write_exp_elt_longcst (selid
);
619 write_exp_elt_longcst (val
); /* Number of args */
626 * Function: specialcmp (char *a, char *b)
628 * Special strcmp: treats ']' and ' ' as end-of-string.
629 * Used for qsorting lists of objc methods (either by class or selector).
633 specialcmp (char *a
, char *b
)
635 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
641 if (*a
&& *a
!= ' ' && *a
!= ']')
642 return 1; /* a is longer therefore greater */
643 if (*b
&& *b
!= ' ' && *b
!= ']')
644 return -1; /* a is shorter therefore lesser */
645 return 0; /* a and b are identical */
649 * Function: compare_selectors (const void *, const void *)
651 * Comparison function for use with qsort. Arguments are symbols or
652 * msymbols Compares selector part of objc method name alphabetically.
656 compare_selectors (const void *a
, const void *b
)
660 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
661 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
662 if (aname
== NULL
|| bname
== NULL
)
663 error (_("internal: compare_selectors(1)"));
665 aname
= strchr(aname
, ' ');
666 bname
= strchr(bname
, ' ');
667 if (aname
== NULL
|| bname
== NULL
)
668 error (_("internal: compare_selectors(2)"));
670 return specialcmp (aname
+1, bname
+1);
674 * Function: selectors_info (regexp, from_tty)
676 * Implements the "Info selectors" command. Takes an optional regexp
677 * arg. Lists all objective c selectors that match the regexp. Works
678 * by grepping thru all symbols for objective c methods. Output list
679 * is sorted and uniqued.
683 selectors_info (char *regexp
, int from_tty
)
685 struct objfile
*objfile
;
686 struct minimal_symbol
*msymbol
;
694 struct symbol
**sym_arr
;
698 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
701 if (*regexp
== '+' || *regexp
== '-')
702 { /* User wants only class methods or only instance methods. */
703 plusminus
= *regexp
++;
704 while (*regexp
== ' ' || *regexp
== '\t')
708 strcpy(myregexp
, ".*]");
711 strcpy(myregexp
, regexp
);
712 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
713 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
715 strcat(myregexp
, ".*]");
721 val
= re_comp (myregexp
);
723 error (_("Invalid regexp (%s): %s"), val
, regexp
);
726 /* First time thru is JUST to get max length and count. */
727 ALL_MSYMBOLS (objfile
, msymbol
)
730 name
= SYMBOL_NATURAL_NAME (msymbol
);
732 (name
[0] == '-' || name
[0] == '+') &&
733 name
[1] == '[') /* Got a method name. */
735 /* Filter for class/instance methods. */
736 if (plusminus
&& name
[0] != plusminus
)
738 /* Find selector part. */
739 name
= (char *) strchr(name
+2, ' ');
740 if (regexp
== NULL
|| re_exec(++name
) != 0)
742 char *mystart
= name
;
743 char *myend
= (char *) strchr(mystart
, ']');
745 if (myend
&& (myend
- mystart
> maxlen
))
746 maxlen
= myend
- mystart
; /* Get longest selector. */
753 printf_filtered (_("Selectors matching \"%s\":\n\n"),
754 regexp
? regexp
: "*");
756 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
758 ALL_MSYMBOLS (objfile
, msymbol
)
761 name
= SYMBOL_NATURAL_NAME (msymbol
);
763 (name
[0] == '-' || name
[0] == '+') &&
764 name
[1] == '[') /* Got a method name. */
766 /* Filter for class/instance methods. */
767 if (plusminus
&& name
[0] != plusminus
)
769 /* Find selector part. */
770 name
= (char *) strchr(name
+2, ' ');
771 if (regexp
== NULL
|| re_exec(++name
) != 0)
772 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
776 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
778 /* Prevent compare on first iteration. */
780 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
785 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
786 name
= strchr (name
, ' ') + 1;
787 if (p
[0] && specialcmp(name
, p
) == 0)
788 continue; /* Seen this one already (not unique). */
790 /* Copy selector part. */
791 while (*name
&& *name
!= ']')
794 /* Print in columns. */
795 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
800 printf_filtered (_("No selectors matching \"%s\"\n"), regexp
? regexp
: "*");
804 * Function: compare_classes (const void *, const void *)
806 * Comparison function for use with qsort. Arguments are symbols or
807 * msymbols Compares class part of objc method name alphabetically.
811 compare_classes (const void *a
, const void *b
)
815 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
816 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
817 if (aname
== NULL
|| bname
== NULL
)
818 error (_("internal: compare_classes(1)"));
820 return specialcmp (aname
+1, bname
+1);
824 * Function: classes_info(regexp, from_tty)
826 * Implements the "info classes" command for objective c classes.
827 * Lists all objective c classes that match the optional regexp.
828 * Works by grepping thru the list of objective c methods. List will
829 * be sorted and uniqued (since one class may have many methods).
830 * BUGS: will not list a class that has no methods.
834 classes_info (char *regexp
, int from_tty
)
836 struct objfile
*objfile
;
837 struct minimal_symbol
*msymbol
;
845 struct symbol
**sym_arr
;
848 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
851 strcpy(myregexp
, regexp
);
852 if (myregexp
[strlen(myregexp
) - 1] == '$')
853 /* In the method name, the end of the class name is marked by ' '. */
854 myregexp
[strlen(myregexp
) - 1] = ' ';
856 strcat(myregexp
, ".* ");
861 val
= re_comp (myregexp
);
863 error (_("Invalid regexp (%s): %s"), val
, regexp
);
866 /* First time thru is JUST to get max length and count. */
867 ALL_MSYMBOLS (objfile
, msymbol
)
870 name
= SYMBOL_NATURAL_NAME (msymbol
);
872 (name
[0] == '-' || name
[0] == '+') &&
873 name
[1] == '[') /* Got a method name. */
874 if (regexp
== NULL
|| re_exec(name
+2) != 0)
876 /* Compute length of classname part. */
877 char *mystart
= name
+ 2;
878 char *myend
= (char *) strchr(mystart
, ' ');
880 if (myend
&& (myend
- mystart
> maxlen
))
881 maxlen
= myend
- mystart
;
887 printf_filtered (_("Classes matching \"%s\":\n\n"),
888 regexp
? regexp
: "*");
889 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
891 ALL_MSYMBOLS (objfile
, msymbol
)
894 name
= SYMBOL_NATURAL_NAME (msymbol
);
896 (name
[0] == '-' || name
[0] == '+') &&
897 name
[1] == '[') /* Got a method name. */
898 if (regexp
== NULL
|| re_exec(name
+2) != 0)
899 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
902 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
904 /* Prevent compare on first iteration. */
906 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
911 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
913 if (p
[0] && specialcmp(name
, p
) == 0)
914 continue; /* Seen this one already (not unique). */
916 /* Copy class part of method name. */
917 while (*name
&& *name
!= ' ')
920 /* Print in columns. */
921 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
926 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
930 * Function: find_imps (char *selector, struct symbol **sym_arr)
932 * Input: a string representing a selector
933 * a pointer to an array of symbol pointers
934 * possibly a pointer to a symbol found by the caller.
936 * Output: number of methods that implement that selector. Side
937 * effects: The array of symbol pointers is filled with matching syms.
939 * By analogy with function "find_methods" (symtab.c), builds a list
940 * of symbols matching the ambiguous input, so that "decode_line_2"
941 * (symtab.c) can list them and ask the user to choose one or more.
942 * In this case the matches are objective c methods
943 * ("implementations") matching an objective c selector.
945 * Note that it is possible for a normal (c-style) function to have
946 * the same name as an objective c selector. To prevent the selector
947 * from eclipsing the function, we allow the caller (decode_line_1) to
948 * search for such a function first, and if it finds one, pass it in
949 * to us. We will then integrate it into the list. We also search
950 * for one here, among the minsyms.
952 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
953 * into two parts: debuggable (struct symbol) syms, and
954 * non_debuggable (struct minimal_symbol) syms. The debuggable
955 * ones will come first, before NUM_DEBUGGABLE (which will thus
956 * be the index of the first non-debuggable one).
960 * Function: total_number_of_imps (char *selector);
962 * Input: a string representing a selector
963 * Output: number of methods that implement that selector.
965 * By analogy with function "total_number_of_methods", this allows
966 * decode_line_1 (symtab.c) to detect if there are objective c methods
967 * matching the input, and to allocate an array of pointers to them
968 * which can be manipulated by "decode_line_2" (also in symtab.c).
972 parse_selector (char *method
, char **selector
)
978 char *nselector
= NULL
;
980 gdb_assert (selector
!= NULL
);
984 while (isspace (*s1
))
991 while (isspace (*s1
))
998 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1000 else if (isspace (*s2
))
1002 else if ((*s2
== '\0') || (*s2
== '\''))
1010 while (isspace (*s2
))
1016 while (isspace (*s2
))
1020 if (selector
!= NULL
)
1021 *selector
= nselector
;
1027 parse_method (char *method
, char *type
, char **class,
1028 char **category
, char **selector
)
1032 int found_quote
= 0;
1035 char *nclass
= NULL
;
1036 char *ncategory
= NULL
;
1037 char *nselector
= NULL
;
1039 gdb_assert (type
!= NULL
);
1040 gdb_assert (class != NULL
);
1041 gdb_assert (category
!= NULL
);
1042 gdb_assert (selector
!= NULL
);
1046 while (isspace (*s1
))
1053 while (isspace (*s1
))
1056 if ((s1
[0] == '+') || (s1
[0] == '-'))
1059 while (isspace (*s1
))
1067 while (isalnum (*s1
) || (*s1
== '_'))
1071 while (isspace (*s2
))
1077 while (isspace (*s2
))
1080 while (isalnum (*s2
) || (*s2
== '_'))
1085 /* Truncate the class name now that we're not using the open paren. */
1092 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1094 else if (isspace (*s2
))
1096 else if (*s2
== ']')
1105 while (isspace (*s2
))
1112 while (isspace (*s2
))
1120 if (category
!= NULL
)
1121 *category
= ncategory
;
1122 if (selector
!= NULL
)
1123 *selector
= nselector
;
1129 find_methods (struct symtab
*symtab
, char type
,
1130 const char *class, const char *category
,
1131 const char *selector
, struct symbol
**syms
,
1132 unsigned int *nsym
, unsigned int *ndebug
)
1134 struct objfile
*objfile
= NULL
;
1135 struct minimal_symbol
*msymbol
= NULL
;
1136 struct block
*block
= NULL
;
1137 struct symbol
*sym
= NULL
;
1139 char *symname
= NULL
;
1142 char *nclass
= NULL
;
1143 char *ncategory
= NULL
;
1144 char *nselector
= NULL
;
1146 unsigned int csym
= 0;
1147 unsigned int cdebug
= 0;
1149 static char *tmp
= NULL
;
1150 static unsigned int tmplen
= 0;
1152 gdb_assert (nsym
!= NULL
);
1153 gdb_assert (ndebug
!= NULL
);
1156 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1158 ALL_OBJFILES (objfile
)
1160 unsigned int *objc_csym
;
1162 /* The objfile_csym variable counts the number of ObjC methods
1163 that this objfile defines. We save that count as a private
1164 objfile data. If we have already determined that this objfile
1165 provides no ObjC methods, we can skip it entirely. */
1167 unsigned int objfile_csym
= 0;
1169 objc_csym
= objfile_data (objfile
, objc_objfile_data
);
1170 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1171 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1174 ALL_OBJFILE_MSYMBOLS (objfile
, msymbol
)
1176 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1177 CORE_ADDR pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
1181 /* Check the symbol name first as this can be done entirely without
1182 sending any query to the target. */
1183 symname
= SYMBOL_NATURAL_NAME (msymbol
);
1184 if (symname
== NULL
)
1187 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1188 /* Not a method name. */
1191 /* The minimal symbol might point to a function descriptor;
1192 resolve it to the actual code address instead. */
1193 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, pc
,
1197 if (pc
< BLOCK_START (block
) || pc
>= BLOCK_END (block
))
1198 /* Not in the specified symtab. */
1201 /* Now that thinks are a bit sane, clean up the symname. */
1202 while ((strlen (symname
) + 1) >= tmplen
)
1204 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1205 tmp
= xrealloc (tmp
, tmplen
);
1207 strcpy (tmp
, symname
);
1209 if (parse_method (tmp
, &ntype
, &nclass
, &ncategory
, &nselector
) == NULL
)
1214 if ((type
!= '\0') && (ntype
!= type
))
1218 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1221 if ((category
!= NULL
) &&
1222 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1225 if ((selector
!= NULL
) &&
1226 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1229 sym
= find_pc_function (pc
);
1232 const char *newsymname
= SYMBOL_NATURAL_NAME (sym
);
1234 if (strcmp (symname
, newsymname
) == 0)
1236 /* Found a high-level method sym: swap it into the
1237 lower part of sym_arr (below num_debuggable). */
1240 syms
[csym
] = syms
[cdebug
];
1249 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1250 newsymname
, symname
);
1252 syms
[csym
] = (struct symbol
*) msymbol
;
1258 /* Found a non-debuggable method symbol. */
1260 syms
[csym
] = (struct symbol
*) msymbol
;
1264 if (objc_csym
== NULL
)
1266 objc_csym
= obstack_alloc (&objfile
->objfile_obstack
,
1267 sizeof (*objc_csym
));
1268 *objc_csym
= objfile_csym
;
1269 set_objfile_data (objfile
, objc_objfile_data
, objc_csym
);
1272 /* Count of ObjC methods in this objfile should be constant. */
1273 gdb_assert (*objc_csym
== objfile_csym
);
1282 char *find_imps (struct symtab
*symtab
, struct block
*block
,
1283 char *method
, struct symbol
**syms
,
1284 unsigned int *nsym
, unsigned int *ndebug
)
1288 char *category
= NULL
;
1289 char *selector
= NULL
;
1291 unsigned int csym
= 0;
1292 unsigned int cdebug
= 0;
1294 unsigned int ncsym
= 0;
1295 unsigned int ncdebug
= 0;
1300 gdb_assert (nsym
!= NULL
);
1301 gdb_assert (ndebug
!= NULL
);
1308 buf
= (char *) alloca (strlen (method
) + 1);
1309 strcpy (buf
, method
);
1310 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1314 struct symbol
*sym
= NULL
;
1315 struct minimal_symbol
*msym
= NULL
;
1317 strcpy (buf
, method
);
1318 tmp
= parse_selector (buf
, &selector
);
1323 sym
= lookup_symbol (selector
, block
, VAR_DOMAIN
, 0);
1333 msym
= lookup_minimal_symbol (selector
, 0, 0);
1338 syms
[csym
] = (struct symbol
*)msym
;
1344 find_methods (symtab
, type
, class, category
, selector
,
1345 syms
+ csym
, &ncsym
, &ncdebug
);
1347 find_methods (symtab
, type
, class, category
, selector
,
1348 NULL
, &ncsym
, &ncdebug
);
1350 /* If we didn't find any methods, just return. */
1351 if (ncsym
== 0 && ncdebug
== 0)
1354 /* Take debug symbols from the second batch of symbols and swap them
1355 * with debug symbols from the first batch. Repeat until either the
1356 * second section is out of debug symbols or the first section is
1357 * full of debug symbols. Either way we have all debug symbols
1358 * packed to the beginning of the buffer.
1363 while ((cdebug
< csym
) && (ncdebug
> 0))
1365 struct symbol
*s
= NULL
;
1366 /* First non-debugging symbol. */
1367 unsigned int i
= cdebug
;
1368 /* Last of second batch of debug symbols. */
1369 unsigned int j
= csym
+ ncdebug
- 1;
1375 /* We've moved a symbol from the second debug section to the
1391 return method
+ (tmp
- buf
);
1395 /* Sort debuggable symbols. */
1397 qsort (syms
, cdebug
, sizeof (struct minimal_symbol
*),
1400 /* Sort minimal_symbols. */
1401 if ((csym
- cdebug
) > 1)
1402 qsort (&syms
[cdebug
], csym
- cdebug
,
1403 sizeof (struct minimal_symbol
*), compare_classes
);
1405 /* Terminate the sym_arr list. */
1408 return method
+ (tmp
- buf
);
1412 print_object_command (char *args
, int from_tty
)
1414 struct value
*object
, *function
, *description
;
1415 CORE_ADDR string_addr
, object_addr
;
1419 if (!args
|| !*args
)
1421 "The 'print-object' command requires an argument (an Objective-C object)");
1424 struct expression
*expr
= parse_expression (args
);
1425 struct cleanup
*old_chain
=
1426 make_cleanup (free_current_contents
, &expr
);
1429 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1430 expr
, &pc
, EVAL_NORMAL
);
1431 do_cleanups (old_chain
);
1434 /* Validate the address for sanity. */
1435 object_addr
= value_as_long (object
);
1436 read_memory (object_addr
, &c
, 1);
1438 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1439 if (function
== NULL
)
1440 error (_("Unable to locate _NSPrintForDebugger in child process"));
1442 description
= call_function_by_hand (function
, 1, &object
);
1444 string_addr
= value_as_long (description
);
1445 if (string_addr
== 0)
1446 error (_("object returns null description"));
1448 read_memory (string_addr
+ i
++, &c
, 1);
1451 { /* Read and print characters up to EOS. */
1453 printf_filtered ("%c", c
);
1454 read_memory (string_addr
+ i
++, &c
, 1);
1457 printf_filtered(_("<object returns empty description>"));
1458 printf_filtered ("\n");
1461 /* The data structure 'methcalls' is used to detect method calls (thru
1462 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1463 * and ultimately find the method being called.
1466 struct objc_methcall
{
1468 /* Return instance method to be called. */
1469 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1470 /* Start of pc range corresponding to method invocation. */
1472 /* End of pc range corresponding to method invocation. */
1476 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1477 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1478 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1479 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1481 static struct objc_methcall methcalls
[] = {
1482 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1483 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1484 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1485 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1486 { "_objc_getClass", NULL
, 0, 0},
1487 { "_objc_getMetaClass", NULL
, 0, 0}
1490 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1492 /* The following function, "find_objc_msgsend", fills in the data
1493 * structure "objc_msgs" by finding the addresses of each of the
1494 * (currently four) functions that it holds (of which objc_msgSend is
1495 * the first). This must be called each time symbols are loaded, in
1496 * case the functions have moved for some reason.
1500 find_objc_msgsend (void)
1503 for (i
= 0; i
< nmethcalls
; i
++) {
1505 struct minimal_symbol
*func
;
1507 /* Try both with and without underscore. */
1508 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1509 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_')) {
1510 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1513 methcalls
[i
].begin
= 0;
1514 methcalls
[i
].end
= 0;
1518 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1520 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1521 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
1525 /* find_objc_msgcall (replaces pc_off_limits)
1527 * ALL that this function now does is to determine whether the input
1528 * address ("pc") is the address of one of the Objective-C message
1529 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1530 * if so, it returns the address of the method that will be called.
1532 * The old function "pc_off_limits" used to do a lot of other things
1533 * in addition, such as detecting shared library jump stubs and
1534 * returning the address of the shlib function that would be called.
1535 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1536 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1537 * dependent modules.
1540 struct objc_submethod_helper_data
{
1541 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1547 find_objc_msgcall_submethod_helper (void * arg
)
1549 struct objc_submethod_helper_data
*s
=
1550 (struct objc_submethod_helper_data
*) arg
;
1552 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1559 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1563 struct objc_submethod_helper_data s
;
1569 if (catch_errors (find_objc_msgcall_submethod_helper
,
1571 "Unable to determine target of Objective-C method call (ignoring):\n",
1572 RETURN_MASK_ALL
) == 0)
1579 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1583 find_objc_msgsend ();
1589 for (i
= 0; i
< nmethcalls
; i
++)
1590 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1592 if (methcalls
[i
].stop_at
!= NULL
)
1593 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1602 extern initialize_file_ftype _initialize_objc_language
; /* -Wmissing-prototypes */
1605 _initialize_objc_language (void)
1607 add_language (&objc_language_defn
);
1608 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1609 _("All Objective-C selectors, or those matching REGEXP."));
1610 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1611 _("All Objective-C classes, or those matching REGEXP."));
1612 add_com ("print-object", class_vars
, print_object_command
,
1613 _("Ask an Objective-C object to print itself."));
1614 add_com_alias ("po", "print-object", class_vars
, 1);
1618 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1619 struct objc_method
*method
)
1621 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1622 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1623 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1624 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1627 static unsigned long
1628 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1630 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1631 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1635 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1636 unsigned long num
, struct objc_method
*method
)
1638 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1639 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1643 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1644 struct objc_object
*object
)
1646 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1647 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1651 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1652 struct objc_super
*super
)
1654 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1655 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1656 super
->class = read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1660 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1661 struct objc_class
*class)
1663 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1664 class->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1665 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1666 class->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1667 class->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1668 class->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1669 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4, byte_order
);
1670 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1671 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1672 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1673 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1677 find_implementation_from_class (struct gdbarch
*gdbarch
,
1678 CORE_ADDR
class, CORE_ADDR sel
)
1680 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1681 CORE_ADDR subclass
= class;
1683 while (subclass
!= 0)
1686 struct objc_class class_str
;
1687 unsigned mlistnum
= 0;
1689 read_objc_class (gdbarch
, subclass
, &class_str
);
1694 unsigned long nmethods
;
1697 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1703 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1705 for (i
= 0; i
< nmethods
; i
++)
1707 struct objc_method meth_str
;
1708 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1712 "checking method 0x%lx against selector 0x%lx\n",
1713 meth_str
.name
, sel
);
1716 if (meth_str
.name
== sel
)
1717 /* FIXME: hppa arch was doing a pointer dereference
1718 here. There needs to be a better way to do that. */
1719 return meth_str
.imp
;
1723 subclass
= class_str
.super_class
;
1730 find_implementation (struct gdbarch
*gdbarch
,
1731 CORE_ADDR object
, CORE_ADDR sel
)
1733 struct objc_object ostr
;
1737 read_objc_object (gdbarch
, object
, &ostr
);
1741 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1745 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1747 struct frame_info
*frame
= get_current_frame ();
1748 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1749 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1755 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1756 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1758 res
= find_implementation (gdbarch
, object
, sel
);
1767 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1769 struct frame_info
*frame
= get_current_frame ();
1770 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1771 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1777 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1778 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1780 res
= find_implementation (gdbarch
, object
, sel
);
1789 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1791 struct frame_info
*frame
= get_current_frame ();
1792 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1793 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1795 struct objc_super sstr
;
1801 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1802 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1804 read_objc_super (gdbarch
, super
, &sstr
);
1805 if (sstr
.class == 0)
1808 res
= find_implementation_from_class (gdbarch
, sstr
.class, sel
);
1817 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1819 struct frame_info
*frame
= get_current_frame ();
1820 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1821 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1823 struct objc_super sstr
;
1829 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1830 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1832 read_objc_super (gdbarch
, super
, &sstr
);
1833 if (sstr
.class == 0)
1836 res
= find_implementation_from_class (gdbarch
, sstr
.class, sel
);
1845 _initialize_objc_lang (void)
1847 objc_objfile_data
= register_objfile_data ();