1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008
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 /* Lookup a structure type named "struct NAME", visible in lexical
80 block BLOCK. If NOERR is nonzero, return zero if NAME is not
84 lookup_struct_typedef (char *name
, struct block
*block
, int noerr
)
88 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
95 error (_("No struct type named %s."), name
);
97 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
102 error (_("This context has class, union or enum %s, not a struct."),
109 lookup_objc_class (char *classname
)
111 struct value
* function
, *classval
;
113 if (! target_has_execution
)
115 /* Can't call into inferior to lookup class. */
119 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
120 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
121 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
122 function
= find_function_in_inferior("objc_lookup_class", NULL
);
125 complaint (&symfile_complaints
, _("no way to lookup Objective-C classes"));
129 classval
= value_string (classname
, strlen (classname
) + 1);
130 classval
= value_coerce_array (classval
);
131 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
136 lookup_child_selector (char *selname
)
138 struct value
* function
, *selstring
;
140 if (! target_has_execution
)
142 /* Can't call into inferior to lookup selector. */
146 if (lookup_minimal_symbol("sel_getUid", 0, 0))
147 function
= find_function_in_inferior("sel_getUid", NULL
);
148 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
149 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
152 complaint (&symfile_complaints
, _("no way to lookup Objective-C selectors"));
156 selstring
= value_coerce_array (value_string (selname
,
157 strlen (selname
) + 1));
158 return value_as_long (call_function_by_hand (function
, 1, &selstring
));
162 value_nsstring (char *ptr
, int len
)
164 struct value
*stringValue
[3];
165 struct value
*function
, *nsstringValue
;
168 struct objfile
*objf
;
169 struct gdbarch
*gdbarch
;
171 if (!target_has_execution
)
172 return 0; /* Can't call into inferior to create NSString. */
174 stringValue
[2] = value_string(ptr
, len
);
175 stringValue
[2] = value_coerce_array(stringValue
[2]);
176 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
177 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
179 function
= find_function_in_inferior("_NSNewStringFromCString", &objf
);
180 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
182 else if (lookup_minimal_symbol("istr", 0, 0))
184 function
= find_function_in_inferior("istr", &objf
);
185 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
187 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
190 = find_function_in_inferior("+[NSString stringWithCString:]", &objf
);
191 type
= builtin_type (get_objfile_arch (objf
))->builtin_long
;
193 stringValue
[0] = value_from_longest
194 (type
, lookup_objc_class ("NSString"));
195 stringValue
[1] = value_from_longest
196 (type
, lookup_child_selector ("stringWithCString:"));
197 nsstringValue
= call_function_by_hand(function
, 3, &stringValue
[0]);
200 error (_("NSString: internal error -- no way to create new NSString"));
202 gdbarch
= get_objfile_arch (objf
);
204 sym
= lookup_struct_typedef("NSString", 0, 1);
206 sym
= lookup_struct_typedef("NXString", 0, 1);
208 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
210 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
212 deprecated_set_value_type (nsstringValue
, type
);
213 return nsstringValue
;
216 /* Objective-C name demangling. */
219 objc_demangle (const char *mangled
, int options
)
221 char *demangled
, *cp
;
223 if (mangled
[0] == '_' &&
224 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
227 cp
= demangled
= xmalloc(strlen(mangled
) + 2);
229 if (mangled
[1] == 'i')
230 *cp
++ = '-'; /* for instance method */
232 *cp
++ = '+'; /* for class method */
234 *cp
++ = '['; /* opening left brace */
235 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
237 while (*cp
&& *cp
== '_')
238 cp
++; /* skip any initial underbars in class name */
240 cp
= strchr(cp
, '_');
241 if (!cp
) /* find first non-initial underbar */
243 xfree(demangled
); /* not mangled name */
246 if (cp
[1] == '_') { /* easy case: no category name */
247 *cp
++ = ' '; /* replace two '_' with one ' ' */
248 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
251 *cp
++ = '('; /* less easy case: category name */
252 cp
= strchr(cp
, '_');
255 xfree(demangled
); /* not mangled name */
259 *cp
++ = ' '; /* overwriting 1st char of method name... */
260 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
263 while (*cp
&& *cp
== '_')
264 cp
++; /* skip any initial underbars in method name */
268 *cp
= ':'; /* replace remaining '_' with ':' */
270 *cp
++ = ']'; /* closing right brace */
271 *cp
++ = 0; /* string terminator */
275 return NULL
; /* Not an objc mangled name. */
278 /* Print the character C on STREAM as part of the contents of a
279 literal string whose delimiter is QUOTER. Note that that format
280 for printing characters and strings is language specific. */
283 objc_emit_char (int c
, struct ui_file
*stream
, int quoter
)
286 c
&= 0xFF; /* Avoid sign bit follies. */
288 if (PRINT_LITERAL_FORM (c
))
290 if (c
== '\\' || c
== quoter
)
292 fputs_filtered ("\\", stream
);
294 fprintf_filtered (stream
, "%c", c
);
301 fputs_filtered ("\\n", stream
);
304 fputs_filtered ("\\b", stream
);
307 fputs_filtered ("\\t", stream
);
310 fputs_filtered ("\\f", stream
);
313 fputs_filtered ("\\r", stream
);
316 fputs_filtered ("\\e", stream
);
319 fputs_filtered ("\\a", stream
);
322 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
329 objc_printchar (int c
, struct ui_file
*stream
)
331 fputs_filtered ("'", stream
);
332 objc_emit_char (c
, stream
, '\'');
333 fputs_filtered ("'", stream
);
336 /* Print the character string STRING, printing at most LENGTH
337 characters. Printing stops early if the number hits print_max;
338 repeat counts are printed as appropriate. Print ellipses at the
339 end if we had to stop before printing LENGTH characters, or if
343 objc_printstr (struct ui_file
*stream
, const gdb_byte
*string
,
344 unsigned int length
, int width
, int force_ellipses
)
347 unsigned int things_printed
= 0;
351 /* If the string was not truncated due to `set print elements', and
352 the last byte of it is a null, we don't print that, in
353 traditional C style. */
354 if ((!force_ellipses
) && length
> 0 && string
[length
-1] == '\0')
359 fputs_filtered ("\"\"", stream
);
363 for (i
= 0; i
< length
&& things_printed
< print_max
; ++i
)
365 /* Position of the character we are examining to see whether it
368 /* Number of repetitions we have detected so far. */
375 fputs_filtered (", ", stream
);
381 while (rep1
< length
&& string
[rep1
] == string
[i
])
387 if (reps
> repeat_count_threshold
)
392 fputs_filtered ("\\\", ", stream
);
394 fputs_filtered ("\", ", stream
);
397 objc_printchar (string
[i
], stream
);
398 fprintf_filtered (stream
, " <repeats %u times>", reps
);
400 things_printed
+= repeat_count_threshold
;
408 fputs_filtered ("\\\"", stream
);
410 fputs_filtered ("\"", stream
);
413 objc_emit_char (string
[i
], stream
, '"');
418 /* Terminate the quotes if necessary. */
422 fputs_filtered ("\\\"", stream
);
424 fputs_filtered ("\"", stream
);
427 if (force_ellipses
|| i
< length
)
428 fputs_filtered ("...", stream
);
431 /* Determine if we are currently in the Objective-C dispatch function.
432 If so, get the address of the method function that the dispatcher
433 would call and use that as the function to step into instead. Also
434 skip over the trampoline for the function (if any). This is better
435 for the user since they are only interested in stepping into the
436 method function anyway. */
438 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
440 CORE_ADDR real_stop_pc
;
441 CORE_ADDR method_stop_pc
;
443 real_stop_pc
= gdbarch_skip_trampoline_code
444 (current_gdbarch
, frame
, stop_pc
);
446 if (real_stop_pc
!= 0)
447 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
449 find_objc_msgcall (stop_pc
, &method_stop_pc
);
453 real_stop_pc
= gdbarch_skip_trampoline_code
454 (current_gdbarch
, frame
, method_stop_pc
);
455 if (real_stop_pc
== 0)
456 real_stop_pc
= method_stop_pc
;
463 /* Table mapping opcodes into strings for printing operators
464 and precedences of the operators. */
466 static const struct op_print objc_op_print_tab
[] =
468 {",", BINOP_COMMA
, PREC_COMMA
, 0},
469 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
470 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
471 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
472 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
473 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
474 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
475 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
476 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
477 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
478 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
479 {">", BINOP_GTR
, PREC_ORDER
, 0},
480 {"<", BINOP_LESS
, PREC_ORDER
, 0},
481 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
482 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
483 {"+", BINOP_ADD
, PREC_ADD
, 0},
484 {"-", BINOP_SUB
, PREC_ADD
, 0},
485 {"*", BINOP_MUL
, PREC_MUL
, 0},
486 {"/", BINOP_DIV
, PREC_MUL
, 0},
487 {"%", BINOP_REM
, PREC_MUL
, 0},
488 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
489 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
490 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
491 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
492 {"*", UNOP_IND
, PREC_PREFIX
, 0},
493 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
494 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
495 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
496 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
497 {NULL
, OP_NULL
, PREC_NULL
, 0}
500 const struct language_defn objc_language_defn
= {
501 "objective-c", /* Language name */
507 &exp_descriptor_standard
,
511 objc_printchar
, /* Print a character constant */
512 objc_printstr
, /* Function to print string constant */
514 c_print_type
, /* Print a type using appropriate syntax */
515 c_print_typedef
, /* Print a typedef using appropriate syntax */
516 c_val_print
, /* Print a value using appropriate syntax */
517 c_value_print
, /* Print a top-level value */
518 objc_skip_trampoline
, /* Language specific skip_trampoline */
519 "self", /* name_of_this */
520 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
521 basic_lookup_transparent_type
,/* lookup_transparent_type */
522 objc_demangle
, /* Language specific symbol demangler */
523 NULL
, /* Language specific class_name_from_physname */
524 objc_op_print_tab
, /* Expression operators for printing */
525 1, /* C-style arrays */
526 0, /* String lower bound */
527 default_word_break_characters
,
528 default_make_symbol_completion_list
,
529 c_language_arch_info
,
530 default_print_array_index
,
531 default_pass_by_reference
,
537 * Following functions help construct Objective-C message calls
540 struct selname
/* For parsing Objective-C. */
542 struct selname
*next
;
547 static int msglist_len
;
548 static struct selname
*selname_chain
;
549 static char *msglist_sel
;
554 struct selname
*new =
555 (struct selname
*) xmalloc (sizeof (struct selname
));
557 new->next
= selname_chain
;
558 new->msglist_len
= msglist_len
;
559 new->msglist_sel
= msglist_sel
;
561 msglist_sel
= (char *)xmalloc(1);
567 add_msglist(struct stoken
*str
, int addcolon
)
572 if (str
== 0) { /* Unnamed arg, or... */
573 if (addcolon
== 0) { /* variable number of args. */
583 len
= plen
+ strlen(msglist_sel
) + 2;
584 s
= (char *)xmalloc(len
);
585 strcpy(s
, msglist_sel
);
600 int val
= msglist_len
;
601 struct selname
*sel
= selname_chain
;
602 char *p
= msglist_sel
;
605 selname_chain
= sel
->next
;
606 msglist_len
= sel
->msglist_len
;
607 msglist_sel
= sel
->msglist_sel
;
608 selid
= lookup_child_selector(p
);
610 error (_("Can't find selector \"%s\""), p
);
611 write_exp_elt_longcst (selid
);
613 write_exp_elt_longcst (val
); /* Number of args */
620 * Function: specialcmp (char *a, char *b)
622 * Special strcmp: treats ']' and ' ' as end-of-string.
623 * Used for qsorting lists of objc methods (either by class or selector).
627 specialcmp (char *a
, char *b
)
629 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
635 if (*a
&& *a
!= ' ' && *a
!= ']')
636 return 1; /* a is longer therefore greater */
637 if (*b
&& *b
!= ' ' && *b
!= ']')
638 return -1; /* a is shorter therefore lesser */
639 return 0; /* a and b are identical */
643 * Function: compare_selectors (const void *, const void *)
645 * Comparison function for use with qsort. Arguments are symbols or
646 * msymbols Compares selector part of objc method name alphabetically.
650 compare_selectors (const void *a
, const void *b
)
654 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
655 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
656 if (aname
== NULL
|| bname
== NULL
)
657 error (_("internal: compare_selectors(1)"));
659 aname
= strchr(aname
, ' ');
660 bname
= strchr(bname
, ' ');
661 if (aname
== NULL
|| bname
== NULL
)
662 error (_("internal: compare_selectors(2)"));
664 return specialcmp (aname
+1, bname
+1);
668 * Function: selectors_info (regexp, from_tty)
670 * Implements the "Info selectors" command. Takes an optional regexp
671 * arg. Lists all objective c selectors that match the regexp. Works
672 * by grepping thru all symbols for objective c methods. Output list
673 * is sorted and uniqued.
677 selectors_info (char *regexp
, int from_tty
)
679 struct objfile
*objfile
;
680 struct minimal_symbol
*msymbol
;
688 struct symbol
**sym_arr
;
692 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
695 if (*regexp
== '+' || *regexp
== '-')
696 { /* User wants only class methods or only instance methods. */
697 plusminus
= *regexp
++;
698 while (*regexp
== ' ' || *regexp
== '\t')
702 strcpy(myregexp
, ".*]");
705 strcpy(myregexp
, regexp
);
706 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
707 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
709 strcat(myregexp
, ".*]");
715 val
= re_comp (myregexp
);
717 error (_("Invalid regexp (%s): %s"), val
, regexp
);
720 /* First time thru is JUST to get max length and count. */
721 ALL_MSYMBOLS (objfile
, msymbol
)
724 name
= SYMBOL_NATURAL_NAME (msymbol
);
726 (name
[0] == '-' || name
[0] == '+') &&
727 name
[1] == '[') /* Got a method name. */
729 /* Filter for class/instance methods. */
730 if (plusminus
&& name
[0] != plusminus
)
732 /* Find selector part. */
733 name
= (char *) strchr(name
+2, ' ');
734 if (regexp
== NULL
|| re_exec(++name
) != 0)
736 char *mystart
= name
;
737 char *myend
= (char *) strchr(mystart
, ']');
739 if (myend
&& (myend
- mystart
> maxlen
))
740 maxlen
= myend
- mystart
; /* Get longest selector. */
747 printf_filtered (_("Selectors matching \"%s\":\n\n"),
748 regexp
? regexp
: "*");
750 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
752 ALL_MSYMBOLS (objfile
, msymbol
)
755 name
= SYMBOL_NATURAL_NAME (msymbol
);
757 (name
[0] == '-' || name
[0] == '+') &&
758 name
[1] == '[') /* Got a method name. */
760 /* Filter for class/instance methods. */
761 if (plusminus
&& name
[0] != plusminus
)
763 /* Find selector part. */
764 name
= (char *) strchr(name
+2, ' ');
765 if (regexp
== NULL
|| re_exec(++name
) != 0)
766 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
770 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
772 /* Prevent compare on first iteration. */
774 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
779 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
780 name
= strchr (name
, ' ') + 1;
781 if (p
[0] && specialcmp(name
, p
) == 0)
782 continue; /* Seen this one already (not unique). */
784 /* Copy selector part. */
785 while (*name
&& *name
!= ']')
788 /* Print in columns. */
789 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
794 printf_filtered (_("No selectors matching \"%s\"\n"), regexp
? regexp
: "*");
798 * Function: compare_classes (const void *, const void *)
800 * Comparison function for use with qsort. Arguments are symbols or
801 * msymbols Compares class part of objc method name alphabetically.
805 compare_classes (const void *a
, const void *b
)
809 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
810 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
811 if (aname
== NULL
|| bname
== NULL
)
812 error (_("internal: compare_classes(1)"));
814 return specialcmp (aname
+1, bname
+1);
818 * Function: classes_info(regexp, from_tty)
820 * Implements the "info classes" command for objective c classes.
821 * Lists all objective c classes that match the optional regexp.
822 * Works by grepping thru the list of objective c methods. List will
823 * be sorted and uniqued (since one class may have many methods).
824 * BUGS: will not list a class that has no methods.
828 classes_info (char *regexp
, int from_tty
)
830 struct objfile
*objfile
;
831 struct minimal_symbol
*msymbol
;
839 struct symbol
**sym_arr
;
842 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
845 strcpy(myregexp
, regexp
);
846 if (myregexp
[strlen(myregexp
) - 1] == '$')
847 /* In the method name, the end of the class name is marked by ' '. */
848 myregexp
[strlen(myregexp
) - 1] = ' ';
850 strcat(myregexp
, ".* ");
855 val
= re_comp (myregexp
);
857 error (_("Invalid regexp (%s): %s"), val
, regexp
);
860 /* First time thru is JUST to get max length and count. */
861 ALL_MSYMBOLS (objfile
, msymbol
)
864 name
= SYMBOL_NATURAL_NAME (msymbol
);
866 (name
[0] == '-' || name
[0] == '+') &&
867 name
[1] == '[') /* Got a method name. */
868 if (regexp
== NULL
|| re_exec(name
+2) != 0)
870 /* Compute length of classname part. */
871 char *mystart
= name
+ 2;
872 char *myend
= (char *) strchr(mystart
, ' ');
874 if (myend
&& (myend
- mystart
> maxlen
))
875 maxlen
= myend
- mystart
;
881 printf_filtered (_("Classes matching \"%s\":\n\n"),
882 regexp
? regexp
: "*");
883 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
885 ALL_MSYMBOLS (objfile
, msymbol
)
888 name
= SYMBOL_NATURAL_NAME (msymbol
);
890 (name
[0] == '-' || name
[0] == '+') &&
891 name
[1] == '[') /* Got a method name. */
892 if (regexp
== NULL
|| re_exec(name
+2) != 0)
893 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
896 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
898 /* Prevent compare on first iteration. */
900 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
905 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
907 if (p
[0] && specialcmp(name
, p
) == 0)
908 continue; /* Seen this one already (not unique). */
910 /* Copy class part of method name. */
911 while (*name
&& *name
!= ' ')
914 /* Print in columns. */
915 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
920 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
924 * Function: find_imps (char *selector, struct symbol **sym_arr)
926 * Input: a string representing a selector
927 * a pointer to an array of symbol pointers
928 * possibly a pointer to a symbol found by the caller.
930 * Output: number of methods that implement that selector. Side
931 * effects: The array of symbol pointers is filled with matching syms.
933 * By analogy with function "find_methods" (symtab.c), builds a list
934 * of symbols matching the ambiguous input, so that "decode_line_2"
935 * (symtab.c) can list them and ask the user to choose one or more.
936 * In this case the matches are objective c methods
937 * ("implementations") matching an objective c selector.
939 * Note that it is possible for a normal (c-style) function to have
940 * the same name as an objective c selector. To prevent the selector
941 * from eclipsing the function, we allow the caller (decode_line_1) to
942 * search for such a function first, and if it finds one, pass it in
943 * to us. We will then integrate it into the list. We also search
944 * for one here, among the minsyms.
946 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
947 * into two parts: debuggable (struct symbol) syms, and
948 * non_debuggable (struct minimal_symbol) syms. The debuggable
949 * ones will come first, before NUM_DEBUGGABLE (which will thus
950 * be the index of the first non-debuggable one).
954 * Function: total_number_of_imps (char *selector);
956 * Input: a string representing a selector
957 * Output: number of methods that implement that selector.
959 * By analogy with function "total_number_of_methods", this allows
960 * decode_line_1 (symtab.c) to detect if there are objective c methods
961 * matching the input, and to allocate an array of pointers to them
962 * which can be manipulated by "decode_line_2" (also in symtab.c).
966 parse_selector (char *method
, char **selector
)
972 char *nselector
= NULL
;
974 gdb_assert (selector
!= NULL
);
978 while (isspace (*s1
))
985 while (isspace (*s1
))
992 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
994 else if (isspace (*s2
))
996 else if ((*s2
== '\0') || (*s2
== '\''))
1004 while (isspace (*s2
))
1010 while (isspace (*s2
))
1014 if (selector
!= NULL
)
1015 *selector
= nselector
;
1021 parse_method (char *method
, char *type
, char **class,
1022 char **category
, char **selector
)
1026 int found_quote
= 0;
1029 char *nclass
= NULL
;
1030 char *ncategory
= NULL
;
1031 char *nselector
= NULL
;
1033 gdb_assert (type
!= NULL
);
1034 gdb_assert (class != NULL
);
1035 gdb_assert (category
!= NULL
);
1036 gdb_assert (selector
!= NULL
);
1040 while (isspace (*s1
))
1047 while (isspace (*s1
))
1050 if ((s1
[0] == '+') || (s1
[0] == '-'))
1053 while (isspace (*s1
))
1061 while (isalnum (*s1
) || (*s1
== '_'))
1065 while (isspace (*s2
))
1071 while (isspace (*s2
))
1074 while (isalnum (*s2
) || (*s2
== '_'))
1079 /* Truncate the class name now that we're not using the open paren. */
1086 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1088 else if (isspace (*s2
))
1090 else if (*s2
== ']')
1099 while (isspace (*s2
))
1106 while (isspace (*s2
))
1114 if (category
!= NULL
)
1115 *category
= ncategory
;
1116 if (selector
!= NULL
)
1117 *selector
= nselector
;
1123 find_methods (struct symtab
*symtab
, char type
,
1124 const char *class, const char *category
,
1125 const char *selector
, struct symbol
**syms
,
1126 unsigned int *nsym
, unsigned int *ndebug
)
1128 struct objfile
*objfile
= NULL
;
1129 struct minimal_symbol
*msymbol
= NULL
;
1130 struct block
*block
= NULL
;
1131 struct symbol
*sym
= NULL
;
1133 char *symname
= NULL
;
1136 char *nclass
= NULL
;
1137 char *ncategory
= NULL
;
1138 char *nselector
= NULL
;
1140 unsigned int csym
= 0;
1141 unsigned int cdebug
= 0;
1143 static char *tmp
= NULL
;
1144 static unsigned int tmplen
= 0;
1146 gdb_assert (nsym
!= NULL
);
1147 gdb_assert (ndebug
!= NULL
);
1150 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1152 ALL_MSYMBOLS (objfile
, msymbol
)
1156 if ((msymbol
->type
!= mst_text
) && (msymbol
->type
!= mst_file_text
))
1157 /* Not a function or method. */
1161 if ((SYMBOL_VALUE_ADDRESS (msymbol
) < BLOCK_START (block
)) ||
1162 (SYMBOL_VALUE_ADDRESS (msymbol
) >= BLOCK_END (block
)))
1163 /* Not in the specified symtab. */
1166 symname
= SYMBOL_NATURAL_NAME (msymbol
);
1167 if (symname
== NULL
)
1170 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1171 /* Not a method name. */
1174 while ((strlen (symname
) + 1) >= tmplen
)
1176 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1177 tmp
= xrealloc (tmp
, tmplen
);
1179 strcpy (tmp
, symname
);
1181 if (parse_method (tmp
, &ntype
, &nclass
, &ncategory
, &nselector
) == NULL
)
1184 if ((type
!= '\0') && (ntype
!= type
))
1188 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1191 if ((category
!= NULL
) &&
1192 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1195 if ((selector
!= NULL
) &&
1196 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1199 sym
= find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol
));
1202 const char *newsymname
= SYMBOL_NATURAL_NAME (sym
);
1204 if (strcmp (symname
, newsymname
) == 0)
1206 /* Found a high-level method sym: swap it into the
1207 lower part of sym_arr (below num_debuggable). */
1210 syms
[csym
] = syms
[cdebug
];
1219 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1220 newsymname
, symname
);
1222 syms
[csym
] = (struct symbol
*) msymbol
;
1228 /* Found a non-debuggable method symbol. */
1230 syms
[csym
] = (struct symbol
*) msymbol
;
1241 char *find_imps (struct symtab
*symtab
, struct block
*block
,
1242 char *method
, struct symbol
**syms
,
1243 unsigned int *nsym
, unsigned int *ndebug
)
1247 char *category
= NULL
;
1248 char *selector
= NULL
;
1250 unsigned int csym
= 0;
1251 unsigned int cdebug
= 0;
1253 unsigned int ncsym
= 0;
1254 unsigned int ncdebug
= 0;
1259 gdb_assert (nsym
!= NULL
);
1260 gdb_assert (ndebug
!= NULL
);
1267 buf
= (char *) alloca (strlen (method
) + 1);
1268 strcpy (buf
, method
);
1269 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1273 struct symbol
*sym
= NULL
;
1274 struct minimal_symbol
*msym
= NULL
;
1276 strcpy (buf
, method
);
1277 tmp
= parse_selector (buf
, &selector
);
1282 sym
= lookup_symbol (selector
, block
, VAR_DOMAIN
, 0);
1292 msym
= lookup_minimal_symbol (selector
, 0, 0);
1297 syms
[csym
] = (struct symbol
*)msym
;
1303 find_methods (symtab
, type
, class, category
, selector
,
1304 syms
+ csym
, &ncsym
, &ncdebug
);
1306 find_methods (symtab
, type
, class, category
, selector
,
1307 NULL
, &ncsym
, &ncdebug
);
1309 /* If we didn't find any methods, just return. */
1310 if (ncsym
== 0 && ncdebug
== 0)
1313 /* Take debug symbols from the second batch of symbols and swap them
1314 * with debug symbols from the first batch. Repeat until either the
1315 * second section is out of debug symbols or the first section is
1316 * full of debug symbols. Either way we have all debug symbols
1317 * packed to the beginning of the buffer.
1322 while ((cdebug
< csym
) && (ncdebug
> 0))
1324 struct symbol
*s
= NULL
;
1325 /* First non-debugging symbol. */
1326 unsigned int i
= cdebug
;
1327 /* Last of second batch of debug symbols. */
1328 unsigned int j
= csym
+ ncdebug
- 1;
1334 /* We've moved a symbol from the second debug section to the
1350 return method
+ (tmp
- buf
);
1354 /* Sort debuggable symbols. */
1356 qsort (syms
, cdebug
, sizeof (struct minimal_symbol
*),
1359 /* Sort minimal_symbols. */
1360 if ((csym
- cdebug
) > 1)
1361 qsort (&syms
[cdebug
], csym
- cdebug
,
1362 sizeof (struct minimal_symbol
*), compare_classes
);
1364 /* Terminate the sym_arr list. */
1367 return method
+ (tmp
- buf
);
1371 print_object_command (char *args
, int from_tty
)
1373 struct value
*object
, *function
, *description
;
1374 CORE_ADDR string_addr
, object_addr
;
1378 if (!args
|| !*args
)
1380 "The 'print-object' command requires an argument (an Objective-C object)");
1383 struct expression
*expr
= parse_expression (args
);
1384 struct cleanup
*old_chain
=
1385 make_cleanup (free_current_contents
, &expr
);
1388 object
= expr
->language_defn
->la_exp_desc
->evaluate_exp
1389 (builtin_type (expr
->gdbarch
)->builtin_data_ptr
, expr
, &pc
, EVAL_NORMAL
);
1390 do_cleanups (old_chain
);
1393 /* Validate the address for sanity. */
1394 object_addr
= value_as_long (object
);
1395 read_memory (object_addr
, &c
, 1);
1397 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1398 if (function
== NULL
)
1399 error (_("Unable to locate _NSPrintForDebugger in child process"));
1401 description
= call_function_by_hand (function
, 1, &object
);
1403 string_addr
= value_as_long (description
);
1404 if (string_addr
== 0)
1405 error (_("object returns null description"));
1407 read_memory (string_addr
+ i
++, &c
, 1);
1410 { /* Read and print characters up to EOS. */
1412 printf_filtered ("%c", c
);
1413 read_memory (string_addr
+ i
++, &c
, 1);
1416 printf_filtered(_("<object returns empty description>"));
1417 printf_filtered ("\n");
1420 /* The data structure 'methcalls' is used to detect method calls (thru
1421 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1422 * and ultimately find the method being called.
1425 struct objc_methcall
{
1427 /* Return instance method to be called. */
1428 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1429 /* Start of pc range corresponding to method invocation. */
1431 /* End of pc range corresponding to method invocation. */
1435 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1436 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1437 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1438 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1440 static struct objc_methcall methcalls
[] = {
1441 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1442 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1443 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1444 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1445 { "_objc_getClass", NULL
, 0, 0},
1446 { "_objc_getMetaClass", NULL
, 0, 0}
1449 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1451 /* The following function, "find_objc_msgsend", fills in the data
1452 * structure "objc_msgs" by finding the addresses of each of the
1453 * (currently four) functions that it holds (of which objc_msgSend is
1454 * the first). This must be called each time symbols are loaded, in
1455 * case the functions have moved for some reason.
1459 find_objc_msgsend (void)
1462 for (i
= 0; i
< nmethcalls
; i
++) {
1464 struct minimal_symbol
*func
;
1466 /* Try both with and without underscore. */
1467 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1468 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_')) {
1469 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1472 methcalls
[i
].begin
= 0;
1473 methcalls
[i
].end
= 0;
1477 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1479 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1480 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
1484 /* find_objc_msgcall (replaces pc_off_limits)
1486 * ALL that this function now does is to determine whether the input
1487 * address ("pc") is the address of one of the Objective-C message
1488 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1489 * if so, it returns the address of the method that will be called.
1491 * The old function "pc_off_limits" used to do a lot of other things
1492 * in addition, such as detecting shared library jump stubs and
1493 * returning the address of the shlib function that would be called.
1494 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1495 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1496 * dependent modules.
1499 struct objc_submethod_helper_data
{
1500 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1506 find_objc_msgcall_submethod_helper (void * arg
)
1508 struct objc_submethod_helper_data
*s
=
1509 (struct objc_submethod_helper_data
*) arg
;
1511 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1518 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1522 struct objc_submethod_helper_data s
;
1528 if (catch_errors (find_objc_msgcall_submethod_helper
,
1530 "Unable to determine target of Objective-C method call (ignoring):\n",
1531 RETURN_MASK_ALL
) == 0)
1538 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1542 find_objc_msgsend ();
1548 for (i
= 0; i
< nmethcalls
; i
++)
1549 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1551 if (methcalls
[i
].stop_at
!= NULL
)
1552 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1561 extern initialize_file_ftype _initialize_objc_language
; /* -Wmissing-prototypes */
1564 _initialize_objc_language (void)
1566 add_language (&objc_language_defn
);
1567 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1568 _("All Objective-C selectors, or those matching REGEXP."));
1569 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1570 _("All Objective-C classes, or those matching REGEXP."));
1571 add_com ("print-object", class_vars
, print_object_command
,
1572 _("Ask an Objective-C object to print itself."));
1573 add_com_alias ("po", "print-object", class_vars
, 1);
1577 read_objc_method (CORE_ADDR addr
, struct objc_method
*method
)
1579 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4);
1580 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4);
1581 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4);
1585 unsigned long read_objc_methlist_nmethods (CORE_ADDR addr
)
1587 return read_memory_unsigned_integer (addr
+ 4, 4);
1591 read_objc_methlist_method (CORE_ADDR addr
, unsigned long num
,
1592 struct objc_method
*method
)
1594 gdb_assert (num
< read_objc_methlist_nmethods (addr
));
1595 read_objc_method (addr
+ 8 + (12 * num
), method
);
1599 read_objc_object (CORE_ADDR addr
, struct objc_object
*object
)
1601 object
->isa
= read_memory_unsigned_integer (addr
, 4);
1605 read_objc_super (CORE_ADDR addr
, struct objc_super
*super
)
1607 super
->receiver
= read_memory_unsigned_integer (addr
, 4);
1608 super
->class = read_memory_unsigned_integer (addr
+ 4, 4);
1612 read_objc_class (CORE_ADDR addr
, struct objc_class
*class)
1614 class->isa
= read_memory_unsigned_integer (addr
, 4);
1615 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4);
1616 class->name
= read_memory_unsigned_integer (addr
+ 8, 4);
1617 class->version
= read_memory_unsigned_integer (addr
+ 12, 4);
1618 class->info
= read_memory_unsigned_integer (addr
+ 16, 4);
1619 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4);
1620 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4);
1621 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4);
1622 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4);
1623 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4);
1627 find_implementation_from_class (CORE_ADDR
class, CORE_ADDR sel
)
1629 CORE_ADDR subclass
= class;
1631 while (subclass
!= 0)
1634 struct objc_class class_str
;
1635 unsigned mlistnum
= 0;
1637 read_objc_class (subclass
, &class_str
);
1642 unsigned long nmethods
;
1645 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1650 nmethods
= read_objc_methlist_nmethods (mlist
);
1652 for (i
= 0; i
< nmethods
; i
++)
1654 struct objc_method meth_str
;
1655 read_objc_methlist_method (mlist
, i
, &meth_str
);
1659 "checking method 0x%lx against selector 0x%lx\n",
1660 meth_str
.name
, sel
);
1663 if (meth_str
.name
== sel
)
1664 /* FIXME: hppa arch was doing a pointer dereference
1665 here. There needs to be a better way to do that. */
1666 return meth_str
.imp
;
1670 subclass
= class_str
.super_class
;
1677 find_implementation (CORE_ADDR object
, CORE_ADDR sel
)
1679 struct objc_object ostr
;
1683 read_objc_object (object
, &ostr
);
1687 return find_implementation_from_class (ostr
.isa
, sel
);
1691 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1693 struct frame_info
*frame
= get_current_frame ();
1694 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1695 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1701 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1702 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1704 res
= find_implementation (object
, sel
);
1713 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1715 struct frame_info
*frame
= get_current_frame ();
1716 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1717 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1723 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1724 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1726 res
= find_implementation (object
, sel
);
1735 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1737 struct frame_info
*frame
= get_current_frame ();
1738 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1739 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1741 struct objc_super sstr
;
1747 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1748 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1750 read_objc_super (super
, &sstr
);
1751 if (sstr
.class == 0)
1754 res
= find_implementation_from_class (sstr
.class, sel
);
1763 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1765 struct frame_info
*frame
= get_current_frame ();
1766 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1767 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1769 struct objc_super sstr
;
1775 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1776 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1778 read_objc_super (super
, &sstr
);
1779 if (sstr
.class == 0)
1782 res
= find_implementation_from_class (sstr
.class, sel
);