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 */
508 &exp_descriptor_standard
,
512 objc_printchar
, /* Print a character constant */
513 objc_printstr
, /* Function to print string constant */
515 c_print_type
, /* Print a type using appropriate syntax */
516 c_print_typedef
, /* Print a typedef using appropriate syntax */
517 c_val_print
, /* Print a value using appropriate syntax */
518 c_value_print
, /* Print a top-level value */
519 objc_skip_trampoline
, /* Language specific skip_trampoline */
520 "self", /* name_of_this */
521 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
522 basic_lookup_transparent_type
,/* lookup_transparent_type */
523 objc_demangle
, /* Language specific symbol demangler */
524 NULL
, /* Language specific class_name_from_physname */
525 objc_op_print_tab
, /* Expression operators for printing */
526 1, /* C-style arrays */
527 0, /* String lower bound */
528 default_word_break_characters
,
529 default_make_symbol_completion_list
,
530 c_language_arch_info
,
531 default_print_array_index
,
532 default_pass_by_reference
,
538 * Following functions help construct Objective-C message calls
541 struct selname
/* For parsing Objective-C. */
543 struct selname
*next
;
548 static int msglist_len
;
549 static struct selname
*selname_chain
;
550 static char *msglist_sel
;
555 struct selname
*new =
556 (struct selname
*) xmalloc (sizeof (struct selname
));
558 new->next
= selname_chain
;
559 new->msglist_len
= msglist_len
;
560 new->msglist_sel
= msglist_sel
;
562 msglist_sel
= (char *)xmalloc(1);
568 add_msglist(struct stoken
*str
, int addcolon
)
573 if (str
== 0) { /* Unnamed arg, or... */
574 if (addcolon
== 0) { /* variable number of args. */
584 len
= plen
+ strlen(msglist_sel
) + 2;
585 s
= (char *)xmalloc(len
);
586 strcpy(s
, msglist_sel
);
601 int val
= msglist_len
;
602 struct selname
*sel
= selname_chain
;
603 char *p
= msglist_sel
;
606 selname_chain
= sel
->next
;
607 msglist_len
= sel
->msglist_len
;
608 msglist_sel
= sel
->msglist_sel
;
609 selid
= lookup_child_selector(p
);
611 error (_("Can't find selector \"%s\""), p
);
612 write_exp_elt_longcst (selid
);
614 write_exp_elt_longcst (val
); /* Number of args */
621 * Function: specialcmp (char *a, char *b)
623 * Special strcmp: treats ']' and ' ' as end-of-string.
624 * Used for qsorting lists of objc methods (either by class or selector).
628 specialcmp (char *a
, char *b
)
630 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
636 if (*a
&& *a
!= ' ' && *a
!= ']')
637 return 1; /* a is longer therefore greater */
638 if (*b
&& *b
!= ' ' && *b
!= ']')
639 return -1; /* a is shorter therefore lesser */
640 return 0; /* a and b are identical */
644 * Function: compare_selectors (const void *, const void *)
646 * Comparison function for use with qsort. Arguments are symbols or
647 * msymbols Compares selector part of objc method name alphabetically.
651 compare_selectors (const void *a
, const void *b
)
655 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
656 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
657 if (aname
== NULL
|| bname
== NULL
)
658 error (_("internal: compare_selectors(1)"));
660 aname
= strchr(aname
, ' ');
661 bname
= strchr(bname
, ' ');
662 if (aname
== NULL
|| bname
== NULL
)
663 error (_("internal: compare_selectors(2)"));
665 return specialcmp (aname
+1, bname
+1);
669 * Function: selectors_info (regexp, from_tty)
671 * Implements the "Info selectors" command. Takes an optional regexp
672 * arg. Lists all objective c selectors that match the regexp. Works
673 * by grepping thru all symbols for objective c methods. Output list
674 * is sorted and uniqued.
678 selectors_info (char *regexp
, int from_tty
)
680 struct objfile
*objfile
;
681 struct minimal_symbol
*msymbol
;
689 struct symbol
**sym_arr
;
693 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
696 if (*regexp
== '+' || *regexp
== '-')
697 { /* User wants only class methods or only instance methods. */
698 plusminus
= *regexp
++;
699 while (*regexp
== ' ' || *regexp
== '\t')
703 strcpy(myregexp
, ".*]");
706 strcpy(myregexp
, regexp
);
707 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
708 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
710 strcat(myregexp
, ".*]");
716 val
= re_comp (myregexp
);
718 error (_("Invalid regexp (%s): %s"), val
, regexp
);
721 /* First time thru is JUST to get max length and count. */
722 ALL_MSYMBOLS (objfile
, msymbol
)
725 name
= SYMBOL_NATURAL_NAME (msymbol
);
727 (name
[0] == '-' || name
[0] == '+') &&
728 name
[1] == '[') /* Got a method name. */
730 /* Filter for class/instance methods. */
731 if (plusminus
&& name
[0] != plusminus
)
733 /* Find selector part. */
734 name
= (char *) strchr(name
+2, ' ');
735 if (regexp
== NULL
|| re_exec(++name
) != 0)
737 char *mystart
= name
;
738 char *myend
= (char *) strchr(mystart
, ']');
740 if (myend
&& (myend
- mystart
> maxlen
))
741 maxlen
= myend
- mystart
; /* Get longest selector. */
748 printf_filtered (_("Selectors matching \"%s\":\n\n"),
749 regexp
? regexp
: "*");
751 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
753 ALL_MSYMBOLS (objfile
, msymbol
)
756 name
= SYMBOL_NATURAL_NAME (msymbol
);
758 (name
[0] == '-' || name
[0] == '+') &&
759 name
[1] == '[') /* Got a method name. */
761 /* Filter for class/instance methods. */
762 if (plusminus
&& name
[0] != plusminus
)
764 /* Find selector part. */
765 name
= (char *) strchr(name
+2, ' ');
766 if (regexp
== NULL
|| re_exec(++name
) != 0)
767 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
771 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
773 /* Prevent compare on first iteration. */
775 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
780 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
781 name
= strchr (name
, ' ') + 1;
782 if (p
[0] && specialcmp(name
, p
) == 0)
783 continue; /* Seen this one already (not unique). */
785 /* Copy selector part. */
786 while (*name
&& *name
!= ']')
789 /* Print in columns. */
790 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
795 printf_filtered (_("No selectors matching \"%s\"\n"), regexp
? regexp
: "*");
799 * Function: compare_classes (const void *, const void *)
801 * Comparison function for use with qsort. Arguments are symbols or
802 * msymbols Compares class part of objc method name alphabetically.
806 compare_classes (const void *a
, const void *b
)
810 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
811 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
812 if (aname
== NULL
|| bname
== NULL
)
813 error (_("internal: compare_classes(1)"));
815 return specialcmp (aname
+1, bname
+1);
819 * Function: classes_info(regexp, from_tty)
821 * Implements the "info classes" command for objective c classes.
822 * Lists all objective c classes that match the optional regexp.
823 * Works by grepping thru the list of objective c methods. List will
824 * be sorted and uniqued (since one class may have many methods).
825 * BUGS: will not list a class that has no methods.
829 classes_info (char *regexp
, int from_tty
)
831 struct objfile
*objfile
;
832 struct minimal_symbol
*msymbol
;
840 struct symbol
**sym_arr
;
843 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
846 strcpy(myregexp
, regexp
);
847 if (myregexp
[strlen(myregexp
) - 1] == '$')
848 /* In the method name, the end of the class name is marked by ' '. */
849 myregexp
[strlen(myregexp
) - 1] = ' ';
851 strcat(myregexp
, ".* ");
856 val
= re_comp (myregexp
);
858 error (_("Invalid regexp (%s): %s"), val
, regexp
);
861 /* First time thru is JUST to get max length and count. */
862 ALL_MSYMBOLS (objfile
, msymbol
)
865 name
= SYMBOL_NATURAL_NAME (msymbol
);
867 (name
[0] == '-' || name
[0] == '+') &&
868 name
[1] == '[') /* Got a method name. */
869 if (regexp
== NULL
|| re_exec(name
+2) != 0)
871 /* Compute length of classname part. */
872 char *mystart
= name
+ 2;
873 char *myend
= (char *) strchr(mystart
, ' ');
875 if (myend
&& (myend
- mystart
> maxlen
))
876 maxlen
= myend
- mystart
;
882 printf_filtered (_("Classes matching \"%s\":\n\n"),
883 regexp
? regexp
: "*");
884 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
886 ALL_MSYMBOLS (objfile
, msymbol
)
889 name
= SYMBOL_NATURAL_NAME (msymbol
);
891 (name
[0] == '-' || name
[0] == '+') &&
892 name
[1] == '[') /* Got a method name. */
893 if (regexp
== NULL
|| re_exec(name
+2) != 0)
894 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
897 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
899 /* Prevent compare on first iteration. */
901 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
906 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
908 if (p
[0] && specialcmp(name
, p
) == 0)
909 continue; /* Seen this one already (not unique). */
911 /* Copy class part of method name. */
912 while (*name
&& *name
!= ' ')
915 /* Print in columns. */
916 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
921 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
925 * Function: find_imps (char *selector, struct symbol **sym_arr)
927 * Input: a string representing a selector
928 * a pointer to an array of symbol pointers
929 * possibly a pointer to a symbol found by the caller.
931 * Output: number of methods that implement that selector. Side
932 * effects: The array of symbol pointers is filled with matching syms.
934 * By analogy with function "find_methods" (symtab.c), builds a list
935 * of symbols matching the ambiguous input, so that "decode_line_2"
936 * (symtab.c) can list them and ask the user to choose one or more.
937 * In this case the matches are objective c methods
938 * ("implementations") matching an objective c selector.
940 * Note that it is possible for a normal (c-style) function to have
941 * the same name as an objective c selector. To prevent the selector
942 * from eclipsing the function, we allow the caller (decode_line_1) to
943 * search for such a function first, and if it finds one, pass it in
944 * to us. We will then integrate it into the list. We also search
945 * for one here, among the minsyms.
947 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
948 * into two parts: debuggable (struct symbol) syms, and
949 * non_debuggable (struct minimal_symbol) syms. The debuggable
950 * ones will come first, before NUM_DEBUGGABLE (which will thus
951 * be the index of the first non-debuggable one).
955 * Function: total_number_of_imps (char *selector);
957 * Input: a string representing a selector
958 * Output: number of methods that implement that selector.
960 * By analogy with function "total_number_of_methods", this allows
961 * decode_line_1 (symtab.c) to detect if there are objective c methods
962 * matching the input, and to allocate an array of pointers to them
963 * which can be manipulated by "decode_line_2" (also in symtab.c).
967 parse_selector (char *method
, char **selector
)
973 char *nselector
= NULL
;
975 gdb_assert (selector
!= NULL
);
979 while (isspace (*s1
))
986 while (isspace (*s1
))
993 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
995 else if (isspace (*s2
))
997 else if ((*s2
== '\0') || (*s2
== '\''))
1005 while (isspace (*s2
))
1011 while (isspace (*s2
))
1015 if (selector
!= NULL
)
1016 *selector
= nselector
;
1022 parse_method (char *method
, char *type
, char **class,
1023 char **category
, char **selector
)
1027 int found_quote
= 0;
1030 char *nclass
= NULL
;
1031 char *ncategory
= NULL
;
1032 char *nselector
= NULL
;
1034 gdb_assert (type
!= NULL
);
1035 gdb_assert (class != NULL
);
1036 gdb_assert (category
!= NULL
);
1037 gdb_assert (selector
!= NULL
);
1041 while (isspace (*s1
))
1048 while (isspace (*s1
))
1051 if ((s1
[0] == '+') || (s1
[0] == '-'))
1054 while (isspace (*s1
))
1062 while (isalnum (*s1
) || (*s1
== '_'))
1066 while (isspace (*s2
))
1072 while (isspace (*s2
))
1075 while (isalnum (*s2
) || (*s2
== '_'))
1080 /* Truncate the class name now that we're not using the open paren. */
1087 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1089 else if (isspace (*s2
))
1091 else if (*s2
== ']')
1100 while (isspace (*s2
))
1107 while (isspace (*s2
))
1115 if (category
!= NULL
)
1116 *category
= ncategory
;
1117 if (selector
!= NULL
)
1118 *selector
= nselector
;
1124 find_methods (struct symtab
*symtab
, char type
,
1125 const char *class, const char *category
,
1126 const char *selector
, struct symbol
**syms
,
1127 unsigned int *nsym
, unsigned int *ndebug
)
1129 struct objfile
*objfile
= NULL
;
1130 struct minimal_symbol
*msymbol
= NULL
;
1131 struct block
*block
= NULL
;
1132 struct symbol
*sym
= NULL
;
1134 char *symname
= NULL
;
1137 char *nclass
= NULL
;
1138 char *ncategory
= NULL
;
1139 char *nselector
= NULL
;
1141 unsigned int csym
= 0;
1142 unsigned int cdebug
= 0;
1144 static char *tmp
= NULL
;
1145 static unsigned int tmplen
= 0;
1147 gdb_assert (nsym
!= NULL
);
1148 gdb_assert (ndebug
!= NULL
);
1151 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1153 ALL_MSYMBOLS (objfile
, msymbol
)
1157 if ((msymbol
->type
!= mst_text
) && (msymbol
->type
!= mst_file_text
))
1158 /* Not a function or method. */
1162 if ((SYMBOL_VALUE_ADDRESS (msymbol
) < BLOCK_START (block
)) ||
1163 (SYMBOL_VALUE_ADDRESS (msymbol
) >= BLOCK_END (block
)))
1164 /* Not in the specified symtab. */
1167 symname
= SYMBOL_NATURAL_NAME (msymbol
);
1168 if (symname
== NULL
)
1171 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1172 /* Not a method name. */
1175 while ((strlen (symname
) + 1) >= tmplen
)
1177 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1178 tmp
= xrealloc (tmp
, tmplen
);
1180 strcpy (tmp
, symname
);
1182 if (parse_method (tmp
, &ntype
, &nclass
, &ncategory
, &nselector
) == NULL
)
1185 if ((type
!= '\0') && (ntype
!= type
))
1189 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1192 if ((category
!= NULL
) &&
1193 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1196 if ((selector
!= NULL
) &&
1197 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1200 sym
= find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol
));
1203 const char *newsymname
= SYMBOL_NATURAL_NAME (sym
);
1205 if (strcmp (symname
, newsymname
) == 0)
1207 /* Found a high-level method sym: swap it into the
1208 lower part of sym_arr (below num_debuggable). */
1211 syms
[csym
] = syms
[cdebug
];
1220 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1221 newsymname
, symname
);
1223 syms
[csym
] = (struct symbol
*) msymbol
;
1229 /* Found a non-debuggable method symbol. */
1231 syms
[csym
] = (struct symbol
*) msymbol
;
1242 char *find_imps (struct symtab
*symtab
, struct block
*block
,
1243 char *method
, struct symbol
**syms
,
1244 unsigned int *nsym
, unsigned int *ndebug
)
1248 char *category
= NULL
;
1249 char *selector
= NULL
;
1251 unsigned int csym
= 0;
1252 unsigned int cdebug
= 0;
1254 unsigned int ncsym
= 0;
1255 unsigned int ncdebug
= 0;
1260 gdb_assert (nsym
!= NULL
);
1261 gdb_assert (ndebug
!= NULL
);
1268 buf
= (char *) alloca (strlen (method
) + 1);
1269 strcpy (buf
, method
);
1270 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1274 struct symbol
*sym
= NULL
;
1275 struct minimal_symbol
*msym
= NULL
;
1277 strcpy (buf
, method
);
1278 tmp
= parse_selector (buf
, &selector
);
1283 sym
= lookup_symbol (selector
, block
, VAR_DOMAIN
, 0);
1293 msym
= lookup_minimal_symbol (selector
, 0, 0);
1298 syms
[csym
] = (struct symbol
*)msym
;
1304 find_methods (symtab
, type
, class, category
, selector
,
1305 syms
+ csym
, &ncsym
, &ncdebug
);
1307 find_methods (symtab
, type
, class, category
, selector
,
1308 NULL
, &ncsym
, &ncdebug
);
1310 /* If we didn't find any methods, just return. */
1311 if (ncsym
== 0 && ncdebug
== 0)
1314 /* Take debug symbols from the second batch of symbols and swap them
1315 * with debug symbols from the first batch. Repeat until either the
1316 * second section is out of debug symbols or the first section is
1317 * full of debug symbols. Either way we have all debug symbols
1318 * packed to the beginning of the buffer.
1323 while ((cdebug
< csym
) && (ncdebug
> 0))
1325 struct symbol
*s
= NULL
;
1326 /* First non-debugging symbol. */
1327 unsigned int i
= cdebug
;
1328 /* Last of second batch of debug symbols. */
1329 unsigned int j
= csym
+ ncdebug
- 1;
1335 /* We've moved a symbol from the second debug section to the
1351 return method
+ (tmp
- buf
);
1355 /* Sort debuggable symbols. */
1357 qsort (syms
, cdebug
, sizeof (struct minimal_symbol
*),
1360 /* Sort minimal_symbols. */
1361 if ((csym
- cdebug
) > 1)
1362 qsort (&syms
[cdebug
], csym
- cdebug
,
1363 sizeof (struct minimal_symbol
*), compare_classes
);
1365 /* Terminate the sym_arr list. */
1368 return method
+ (tmp
- buf
);
1372 print_object_command (char *args
, int from_tty
)
1374 struct value
*object
, *function
, *description
;
1375 CORE_ADDR string_addr
, object_addr
;
1379 if (!args
|| !*args
)
1381 "The 'print-object' command requires an argument (an Objective-C object)");
1384 struct expression
*expr
= parse_expression (args
);
1385 struct cleanup
*old_chain
=
1386 make_cleanup (free_current_contents
, &expr
);
1389 object
= expr
->language_defn
->la_exp_desc
->evaluate_exp
1390 (builtin_type (expr
->gdbarch
)->builtin_data_ptr
, expr
, &pc
, EVAL_NORMAL
);
1391 do_cleanups (old_chain
);
1394 /* Validate the address for sanity. */
1395 object_addr
= value_as_long (object
);
1396 read_memory (object_addr
, &c
, 1);
1398 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1399 if (function
== NULL
)
1400 error (_("Unable to locate _NSPrintForDebugger in child process"));
1402 description
= call_function_by_hand (function
, 1, &object
);
1404 string_addr
= value_as_long (description
);
1405 if (string_addr
== 0)
1406 error (_("object returns null description"));
1408 read_memory (string_addr
+ i
++, &c
, 1);
1411 { /* Read and print characters up to EOS. */
1413 printf_filtered ("%c", c
);
1414 read_memory (string_addr
+ i
++, &c
, 1);
1417 printf_filtered(_("<object returns empty description>"));
1418 printf_filtered ("\n");
1421 /* The data structure 'methcalls' is used to detect method calls (thru
1422 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1423 * and ultimately find the method being called.
1426 struct objc_methcall
{
1428 /* Return instance method to be called. */
1429 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1430 /* Start of pc range corresponding to method invocation. */
1432 /* End of pc range corresponding to method invocation. */
1436 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1437 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1438 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1439 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1441 static struct objc_methcall methcalls
[] = {
1442 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1443 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1444 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1445 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1446 { "_objc_getClass", NULL
, 0, 0},
1447 { "_objc_getMetaClass", NULL
, 0, 0}
1450 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1452 /* The following function, "find_objc_msgsend", fills in the data
1453 * structure "objc_msgs" by finding the addresses of each of the
1454 * (currently four) functions that it holds (of which objc_msgSend is
1455 * the first). This must be called each time symbols are loaded, in
1456 * case the functions have moved for some reason.
1460 find_objc_msgsend (void)
1463 for (i
= 0; i
< nmethcalls
; i
++) {
1465 struct minimal_symbol
*func
;
1467 /* Try both with and without underscore. */
1468 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1469 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_')) {
1470 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1473 methcalls
[i
].begin
= 0;
1474 methcalls
[i
].end
= 0;
1478 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1480 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1481 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
1485 /* find_objc_msgcall (replaces pc_off_limits)
1487 * ALL that this function now does is to determine whether the input
1488 * address ("pc") is the address of one of the Objective-C message
1489 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1490 * if so, it returns the address of the method that will be called.
1492 * The old function "pc_off_limits" used to do a lot of other things
1493 * in addition, such as detecting shared library jump stubs and
1494 * returning the address of the shlib function that would be called.
1495 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1496 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1497 * dependent modules.
1500 struct objc_submethod_helper_data
{
1501 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1507 find_objc_msgcall_submethod_helper (void * arg
)
1509 struct objc_submethod_helper_data
*s
=
1510 (struct objc_submethod_helper_data
*) arg
;
1512 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1519 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1523 struct objc_submethod_helper_data s
;
1529 if (catch_errors (find_objc_msgcall_submethod_helper
,
1531 "Unable to determine target of Objective-C method call (ignoring):\n",
1532 RETURN_MASK_ALL
) == 0)
1539 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1543 find_objc_msgsend ();
1549 for (i
= 0; i
< nmethcalls
; i
++)
1550 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1552 if (methcalls
[i
].stop_at
!= NULL
)
1553 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1562 extern initialize_file_ftype _initialize_objc_language
; /* -Wmissing-prototypes */
1565 _initialize_objc_language (void)
1567 add_language (&objc_language_defn
);
1568 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1569 _("All Objective-C selectors, or those matching REGEXP."));
1570 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1571 _("All Objective-C classes, or those matching REGEXP."));
1572 add_com ("print-object", class_vars
, print_object_command
,
1573 _("Ask an Objective-C object to print itself."));
1574 add_com_alias ("po", "print-object", class_vars
, 1);
1578 read_objc_method (CORE_ADDR addr
, struct objc_method
*method
)
1580 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4);
1581 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4);
1582 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4);
1586 unsigned long read_objc_methlist_nmethods (CORE_ADDR addr
)
1588 return read_memory_unsigned_integer (addr
+ 4, 4);
1592 read_objc_methlist_method (CORE_ADDR addr
, unsigned long num
,
1593 struct objc_method
*method
)
1595 gdb_assert (num
< read_objc_methlist_nmethods (addr
));
1596 read_objc_method (addr
+ 8 + (12 * num
), method
);
1600 read_objc_object (CORE_ADDR addr
, struct objc_object
*object
)
1602 object
->isa
= read_memory_unsigned_integer (addr
, 4);
1606 read_objc_super (CORE_ADDR addr
, struct objc_super
*super
)
1608 super
->receiver
= read_memory_unsigned_integer (addr
, 4);
1609 super
->class = read_memory_unsigned_integer (addr
+ 4, 4);
1613 read_objc_class (CORE_ADDR addr
, struct objc_class
*class)
1615 class->isa
= read_memory_unsigned_integer (addr
, 4);
1616 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4);
1617 class->name
= read_memory_unsigned_integer (addr
+ 8, 4);
1618 class->version
= read_memory_unsigned_integer (addr
+ 12, 4);
1619 class->info
= read_memory_unsigned_integer (addr
+ 16, 4);
1620 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4);
1621 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4);
1622 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4);
1623 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4);
1624 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4);
1628 find_implementation_from_class (CORE_ADDR
class, CORE_ADDR sel
)
1630 CORE_ADDR subclass
= class;
1632 while (subclass
!= 0)
1635 struct objc_class class_str
;
1636 unsigned mlistnum
= 0;
1638 read_objc_class (subclass
, &class_str
);
1643 unsigned long nmethods
;
1646 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1651 nmethods
= read_objc_methlist_nmethods (mlist
);
1653 for (i
= 0; i
< nmethods
; i
++)
1655 struct objc_method meth_str
;
1656 read_objc_methlist_method (mlist
, i
, &meth_str
);
1660 "checking method 0x%lx against selector 0x%lx\n",
1661 meth_str
.name
, sel
);
1664 if (meth_str
.name
== sel
)
1665 /* FIXME: hppa arch was doing a pointer dereference
1666 here. There needs to be a better way to do that. */
1667 return meth_str
.imp
;
1671 subclass
= class_str
.super_class
;
1678 find_implementation (CORE_ADDR object
, CORE_ADDR sel
)
1680 struct objc_object ostr
;
1684 read_objc_object (object
, &ostr
);
1688 return find_implementation_from_class (ostr
.isa
, sel
);
1692 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1694 struct frame_info
*frame
= get_current_frame ();
1695 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1696 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1702 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1703 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1705 res
= find_implementation (object
, sel
);
1714 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1716 struct frame_info
*frame
= get_current_frame ();
1717 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1718 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1724 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1725 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1727 res
= find_implementation (object
, sel
);
1736 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1738 struct frame_info
*frame
= get_current_frame ();
1739 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1740 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1742 struct objc_super sstr
;
1748 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1749 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1751 read_objc_super (super
, &sstr
);
1752 if (sstr
.class == 0)
1755 res
= find_implementation_from_class (sstr
.class, sel
);
1764 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1766 struct frame_info
*frame
= get_current_frame ();
1767 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1768 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1770 struct objc_super sstr
;
1776 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1777 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1779 read_objc_super (super
, &sstr
);
1780 if (sstr
.class == 0)
1783 res
= find_implementation_from_class (sstr
.class, sel
);