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,
89 (struct symtab
**) NULL
);
96 error (_("No struct type named %s."), name
);
98 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
103 error (_("This context has class, union or enum %s, not a struct."),
110 lookup_objc_class (char *classname
)
112 struct value
* function
, *classval
;
114 if (! target_has_execution
)
116 /* Can't call into inferior to lookup class. */
120 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
121 function
= find_function_in_inferior("objc_lookUpClass");
122 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
123 function
= find_function_in_inferior("objc_lookup_class");
126 complaint (&symfile_complaints
, _("no way to lookup Objective-C classes"));
130 classval
= value_string (classname
, strlen (classname
) + 1);
131 classval
= value_coerce_array (classval
);
132 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
137 lookup_child_selector (char *selname
)
139 struct value
* function
, *selstring
;
141 if (! target_has_execution
)
143 /* Can't call into inferior to lookup selector. */
147 if (lookup_minimal_symbol("sel_getUid", 0, 0))
148 function
= find_function_in_inferior("sel_getUid");
149 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
150 function
= find_function_in_inferior("sel_get_any_uid");
153 complaint (&symfile_complaints
, _("no way to lookup Objective-C selectors"));
157 selstring
= value_coerce_array (value_string (selname
,
158 strlen (selname
) + 1));
159 return value_as_long (call_function_by_hand (function
, 1, &selstring
));
163 value_nsstring (char *ptr
, int len
)
165 struct value
*stringValue
[3];
166 struct value
*function
, *nsstringValue
;
170 if (!target_has_execution
)
171 return 0; /* Can't call into inferior to create NSString. */
173 sym
= lookup_struct_typedef("NSString", 0, 1);
175 sym
= lookup_struct_typedef("NXString", 0, 1);
177 type
= lookup_pointer_type(builtin_type_void
);
179 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
181 stringValue
[2] = value_string(ptr
, len
);
182 stringValue
[2] = value_coerce_array(stringValue
[2]);
183 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
184 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
186 function
= find_function_in_inferior("_NSNewStringFromCString");
187 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
189 else if (lookup_minimal_symbol("istr", 0, 0))
191 function
= find_function_in_inferior("istr");
192 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
194 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
196 function
= find_function_in_inferior("+[NSString stringWithCString:]");
197 stringValue
[0] = value_from_longest
198 (builtin_type_long
, lookup_objc_class ("NSString"));
199 stringValue
[1] = value_from_longest
200 (builtin_type_long
, lookup_child_selector ("stringWithCString:"));
201 nsstringValue
= call_function_by_hand(function
, 3, &stringValue
[0]);
204 error (_("NSString: internal error -- no way to create new NSString"));
206 deprecated_set_value_type (nsstringValue
, type
);
207 return nsstringValue
;
210 /* Objective-C name demangling. */
213 objc_demangle (const char *mangled
, int options
)
215 char *demangled
, *cp
;
217 if (mangled
[0] == '_' &&
218 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
221 cp
= demangled
= xmalloc(strlen(mangled
) + 2);
223 if (mangled
[1] == 'i')
224 *cp
++ = '-'; /* for instance method */
226 *cp
++ = '+'; /* for class method */
228 *cp
++ = '['; /* opening left brace */
229 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
231 while (*cp
&& *cp
== '_')
232 cp
++; /* skip any initial underbars in class name */
234 cp
= strchr(cp
, '_');
235 if (!cp
) /* find first non-initial underbar */
237 xfree(demangled
); /* not mangled name */
240 if (cp
[1] == '_') { /* easy case: no category name */
241 *cp
++ = ' '; /* replace two '_' with one ' ' */
242 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
245 *cp
++ = '('; /* less easy case: category name */
246 cp
= strchr(cp
, '_');
249 xfree(demangled
); /* not mangled name */
253 *cp
++ = ' '; /* overwriting 1st char of method name... */
254 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
257 while (*cp
&& *cp
== '_')
258 cp
++; /* skip any initial underbars in method name */
262 *cp
= ':'; /* replace remaining '_' with ':' */
264 *cp
++ = ']'; /* closing right brace */
265 *cp
++ = 0; /* string terminator */
269 return NULL
; /* Not an objc mangled name. */
272 /* Print the character C on STREAM as part of the contents of a
273 literal string whose delimiter is QUOTER. Note that that format
274 for printing characters and strings is language specific. */
277 objc_emit_char (int c
, struct ui_file
*stream
, int quoter
)
280 c
&= 0xFF; /* Avoid sign bit follies. */
282 if (PRINT_LITERAL_FORM (c
))
284 if (c
== '\\' || c
== quoter
)
286 fputs_filtered ("\\", stream
);
288 fprintf_filtered (stream
, "%c", c
);
295 fputs_filtered ("\\n", stream
);
298 fputs_filtered ("\\b", stream
);
301 fputs_filtered ("\\t", stream
);
304 fputs_filtered ("\\f", stream
);
307 fputs_filtered ("\\r", stream
);
310 fputs_filtered ("\\e", stream
);
313 fputs_filtered ("\\a", stream
);
316 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
323 objc_printchar (int c
, struct ui_file
*stream
)
325 fputs_filtered ("'", stream
);
326 objc_emit_char (c
, stream
, '\'');
327 fputs_filtered ("'", stream
);
330 /* Print the character string STRING, printing at most LENGTH
331 characters. Printing stops early if the number hits print_max;
332 repeat counts are printed as appropriate. Print ellipses at the
333 end if we had to stop before printing LENGTH characters, or if
337 objc_printstr (struct ui_file
*stream
, const gdb_byte
*string
,
338 unsigned int length
, int width
, int force_ellipses
)
341 unsigned int things_printed
= 0;
345 /* If the string was not truncated due to `set print elements', and
346 the last byte of it is a null, we don't print that, in
347 traditional C style. */
348 if ((!force_ellipses
) && length
> 0 && string
[length
-1] == '\0')
353 fputs_filtered ("\"\"", stream
);
357 for (i
= 0; i
< length
&& things_printed
< print_max
; ++i
)
359 /* Position of the character we are examining to see whether it
362 /* Number of repetitions we have detected so far. */
369 fputs_filtered (", ", stream
);
375 while (rep1
< length
&& string
[rep1
] == string
[i
])
381 if (reps
> repeat_count_threshold
)
386 fputs_filtered ("\\\", ", stream
);
388 fputs_filtered ("\", ", stream
);
391 objc_printchar (string
[i
], stream
);
392 fprintf_filtered (stream
, " <repeats %u times>", reps
);
394 things_printed
+= repeat_count_threshold
;
402 fputs_filtered ("\\\"", stream
);
404 fputs_filtered ("\"", stream
);
407 objc_emit_char (string
[i
], stream
, '"');
412 /* Terminate the quotes if necessary. */
416 fputs_filtered ("\\\"", stream
);
418 fputs_filtered ("\"", stream
);
421 if (force_ellipses
|| i
< length
)
422 fputs_filtered ("...", stream
);
425 /* Determine if we are currently in the Objective-C dispatch function.
426 If so, get the address of the method function that the dispatcher
427 would call and use that as the function to step into instead. Also
428 skip over the trampoline for the function (if any). This is better
429 for the user since they are only interested in stepping into the
430 method function anyway. */
432 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
434 CORE_ADDR real_stop_pc
;
435 CORE_ADDR method_stop_pc
;
437 real_stop_pc
= gdbarch_skip_trampoline_code
438 (current_gdbarch
, frame
, stop_pc
);
440 if (real_stop_pc
!= 0)
441 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
443 find_objc_msgcall (stop_pc
, &method_stop_pc
);
447 real_stop_pc
= gdbarch_skip_trampoline_code
448 (current_gdbarch
, frame
, method_stop_pc
);
449 if (real_stop_pc
== 0)
450 real_stop_pc
= method_stop_pc
;
457 /* Table mapping opcodes into strings for printing operators
458 and precedences of the operators. */
460 static const struct op_print objc_op_print_tab
[] =
462 {",", BINOP_COMMA
, PREC_COMMA
, 0},
463 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
464 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
465 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
466 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
467 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
468 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
469 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
470 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
471 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
472 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
473 {">", BINOP_GTR
, PREC_ORDER
, 0},
474 {"<", BINOP_LESS
, PREC_ORDER
, 0},
475 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
476 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
477 {"+", BINOP_ADD
, PREC_ADD
, 0},
478 {"-", BINOP_SUB
, PREC_ADD
, 0},
479 {"*", BINOP_MUL
, PREC_MUL
, 0},
480 {"/", BINOP_DIV
, PREC_MUL
, 0},
481 {"%", BINOP_REM
, PREC_MUL
, 0},
482 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
483 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
484 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
485 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
486 {"*", UNOP_IND
, PREC_PREFIX
, 0},
487 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
488 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
489 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
490 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
491 {NULL
, OP_NULL
, PREC_NULL
, 0}
494 const struct language_defn objc_language_defn
= {
495 "objective-c", /* Language name */
501 &exp_descriptor_standard
,
505 objc_printchar
, /* Print a character constant */
506 objc_printstr
, /* Function to print string constant */
508 c_print_type
, /* Print a type using appropriate syntax */
509 c_val_print
, /* Print a value using appropriate syntax */
510 c_value_print
, /* Print a top-level value */
511 objc_skip_trampoline
, /* Language specific skip_trampoline */
512 value_of_this
, /* value_of_this */
513 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
514 basic_lookup_transparent_type
,/* lookup_transparent_type */
515 objc_demangle
, /* Language specific symbol demangler */
516 NULL
, /* Language specific class_name_from_physname */
517 objc_op_print_tab
, /* Expression operators for printing */
518 1, /* C-style arrays */
519 0, /* String lower bound */
520 default_word_break_characters
,
521 c_language_arch_info
,
522 default_print_array_index
,
523 default_pass_by_reference
,
529 * Following functions help construct Objective-C message calls
532 struct selname
/* For parsing Objective-C. */
534 struct selname
*next
;
539 static int msglist_len
;
540 static struct selname
*selname_chain
;
541 static char *msglist_sel
;
546 struct selname
*new =
547 (struct selname
*) xmalloc (sizeof (struct selname
));
549 new->next
= selname_chain
;
550 new->msglist_len
= msglist_len
;
551 new->msglist_sel
= msglist_sel
;
553 msglist_sel
= (char *)xmalloc(1);
559 add_msglist(struct stoken
*str
, int addcolon
)
564 if (str
== 0) { /* Unnamed arg, or... */
565 if (addcolon
== 0) { /* variable number of args. */
575 len
= plen
+ strlen(msglist_sel
) + 2;
576 s
= (char *)xmalloc(len
);
577 strcpy(s
, msglist_sel
);
592 int val
= msglist_len
;
593 struct selname
*sel
= selname_chain
;
594 char *p
= msglist_sel
;
597 selname_chain
= sel
->next
;
598 msglist_len
= sel
->msglist_len
;
599 msglist_sel
= sel
->msglist_sel
;
600 selid
= lookup_child_selector(p
);
602 error (_("Can't find selector \"%s\""), p
);
603 write_exp_elt_longcst (selid
);
605 write_exp_elt_longcst (val
); /* Number of args */
612 * Function: specialcmp (char *a, char *b)
614 * Special strcmp: treats ']' and ' ' as end-of-string.
615 * Used for qsorting lists of objc methods (either by class or selector).
619 specialcmp (char *a
, char *b
)
621 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
627 if (*a
&& *a
!= ' ' && *a
!= ']')
628 return 1; /* a is longer therefore greater */
629 if (*b
&& *b
!= ' ' && *b
!= ']')
630 return -1; /* a is shorter therefore lesser */
631 return 0; /* a and b are identical */
635 * Function: compare_selectors (const void *, const void *)
637 * Comparison function for use with qsort. Arguments are symbols or
638 * msymbols Compares selector part of objc method name alphabetically.
642 compare_selectors (const void *a
, const void *b
)
646 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
647 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
648 if (aname
== NULL
|| bname
== NULL
)
649 error (_("internal: compare_selectors(1)"));
651 aname
= strchr(aname
, ' ');
652 bname
= strchr(bname
, ' ');
653 if (aname
== NULL
|| bname
== NULL
)
654 error (_("internal: compare_selectors(2)"));
656 return specialcmp (aname
+1, bname
+1);
660 * Function: selectors_info (regexp, from_tty)
662 * Implements the "Info selectors" command. Takes an optional regexp
663 * arg. Lists all objective c selectors that match the regexp. Works
664 * by grepping thru all symbols for objective c methods. Output list
665 * is sorted and uniqued.
669 selectors_info (char *regexp
, int from_tty
)
671 struct objfile
*objfile
;
672 struct minimal_symbol
*msymbol
;
680 struct symbol
**sym_arr
;
684 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
687 if (*regexp
== '+' || *regexp
== '-')
688 { /* User wants only class methods or only instance methods. */
689 plusminus
= *regexp
++;
690 while (*regexp
== ' ' || *regexp
== '\t')
694 strcpy(myregexp
, ".*]");
697 strcpy(myregexp
, regexp
);
698 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
699 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
701 strcat(myregexp
, ".*]");
707 val
= re_comp (myregexp
);
709 error (_("Invalid regexp (%s): %s"), val
, regexp
);
712 /* First time thru is JUST to get max length and count. */
713 ALL_MSYMBOLS (objfile
, msymbol
)
716 name
= SYMBOL_NATURAL_NAME (msymbol
);
718 (name
[0] == '-' || name
[0] == '+') &&
719 name
[1] == '[') /* Got a method name. */
721 /* Filter for class/instance methods. */
722 if (plusminus
&& name
[0] != plusminus
)
724 /* Find selector part. */
725 name
= (char *) strchr(name
+2, ' ');
726 if (regexp
== NULL
|| re_exec(++name
) != 0)
728 char *mystart
= name
;
729 char *myend
= (char *) strchr(mystart
, ']');
731 if (myend
&& (myend
- mystart
> maxlen
))
732 maxlen
= myend
- mystart
; /* Get longest selector. */
739 printf_filtered (_("Selectors matching \"%s\":\n\n"),
740 regexp
? regexp
: "*");
742 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
744 ALL_MSYMBOLS (objfile
, msymbol
)
747 name
= SYMBOL_NATURAL_NAME (msymbol
);
749 (name
[0] == '-' || name
[0] == '+') &&
750 name
[1] == '[') /* Got a method name. */
752 /* Filter for class/instance methods. */
753 if (plusminus
&& name
[0] != plusminus
)
755 /* Find selector part. */
756 name
= (char *) strchr(name
+2, ' ');
757 if (regexp
== NULL
|| re_exec(++name
) != 0)
758 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
762 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
764 /* Prevent compare on first iteration. */
766 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
771 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
772 name
= strchr (name
, ' ') + 1;
773 if (p
[0] && specialcmp(name
, p
) == 0)
774 continue; /* Seen this one already (not unique). */
776 /* Copy selector part. */
777 while (*name
&& *name
!= ']')
780 /* Print in columns. */
781 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
786 printf_filtered (_("No selectors matching \"%s\"\n"), regexp
? regexp
: "*");
790 * Function: compare_classes (const void *, const void *)
792 * Comparison function for use with qsort. Arguments are symbols or
793 * msymbols Compares class part of objc method name alphabetically.
797 compare_classes (const void *a
, const void *b
)
801 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
802 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
803 if (aname
== NULL
|| bname
== NULL
)
804 error (_("internal: compare_classes(1)"));
806 return specialcmp (aname
+1, bname
+1);
810 * Function: classes_info(regexp, from_tty)
812 * Implements the "info classes" command for objective c classes.
813 * Lists all objective c classes that match the optional regexp.
814 * Works by grepping thru the list of objective c methods. List will
815 * be sorted and uniqued (since one class may have many methods).
816 * BUGS: will not list a class that has no methods.
820 classes_info (char *regexp
, int from_tty
)
822 struct objfile
*objfile
;
823 struct minimal_symbol
*msymbol
;
831 struct symbol
**sym_arr
;
834 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
837 strcpy(myregexp
, regexp
);
838 if (myregexp
[strlen(myregexp
) - 1] == '$')
839 /* In the method name, the end of the class name is marked by ' '. */
840 myregexp
[strlen(myregexp
) - 1] = ' ';
842 strcat(myregexp
, ".* ");
847 val
= re_comp (myregexp
);
849 error (_("Invalid regexp (%s): %s"), val
, regexp
);
852 /* First time thru is JUST to get max length and count. */
853 ALL_MSYMBOLS (objfile
, msymbol
)
856 name
= SYMBOL_NATURAL_NAME (msymbol
);
858 (name
[0] == '-' || name
[0] == '+') &&
859 name
[1] == '[') /* Got a method name. */
860 if (regexp
== NULL
|| re_exec(name
+2) != 0)
862 /* Compute length of classname part. */
863 char *mystart
= name
+ 2;
864 char *myend
= (char *) strchr(mystart
, ' ');
866 if (myend
&& (myend
- mystart
> maxlen
))
867 maxlen
= myend
- mystart
;
873 printf_filtered (_("Classes matching \"%s\":\n\n"),
874 regexp
? regexp
: "*");
875 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
877 ALL_MSYMBOLS (objfile
, msymbol
)
880 name
= SYMBOL_NATURAL_NAME (msymbol
);
882 (name
[0] == '-' || name
[0] == '+') &&
883 name
[1] == '[') /* Got a method name. */
884 if (regexp
== NULL
|| re_exec(name
+2) != 0)
885 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
888 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
890 /* Prevent compare on first iteration. */
892 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
897 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
899 if (p
[0] && specialcmp(name
, p
) == 0)
900 continue; /* Seen this one already (not unique). */
902 /* Copy class part of method name. */
903 while (*name
&& *name
!= ' ')
906 /* Print in columns. */
907 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
912 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
916 * Function: find_imps (char *selector, struct symbol **sym_arr)
918 * Input: a string representing a selector
919 * a pointer to an array of symbol pointers
920 * possibly a pointer to a symbol found by the caller.
922 * Output: number of methods that implement that selector. Side
923 * effects: The array of symbol pointers is filled with matching syms.
925 * By analogy with function "find_methods" (symtab.c), builds a list
926 * of symbols matching the ambiguous input, so that "decode_line_2"
927 * (symtab.c) can list them and ask the user to choose one or more.
928 * In this case the matches are objective c methods
929 * ("implementations") matching an objective c selector.
931 * Note that it is possible for a normal (c-style) function to have
932 * the same name as an objective c selector. To prevent the selector
933 * from eclipsing the function, we allow the caller (decode_line_1) to
934 * search for such a function first, and if it finds one, pass it in
935 * to us. We will then integrate it into the list. We also search
936 * for one here, among the minsyms.
938 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
939 * into two parts: debuggable (struct symbol) syms, and
940 * non_debuggable (struct minimal_symbol) syms. The debuggable
941 * ones will come first, before NUM_DEBUGGABLE (which will thus
942 * be the index of the first non-debuggable one).
946 * Function: total_number_of_imps (char *selector);
948 * Input: a string representing a selector
949 * Output: number of methods that implement that selector.
951 * By analogy with function "total_number_of_methods", this allows
952 * decode_line_1 (symtab.c) to detect if there are objective c methods
953 * matching the input, and to allocate an array of pointers to them
954 * which can be manipulated by "decode_line_2" (also in symtab.c).
958 parse_selector (char *method
, char **selector
)
964 char *nselector
= NULL
;
966 gdb_assert (selector
!= NULL
);
970 while (isspace (*s1
))
977 while (isspace (*s1
))
984 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
986 else if (isspace (*s2
))
988 else if ((*s2
== '\0') || (*s2
== '\''))
996 while (isspace (*s2
))
1002 while (isspace (*s2
))
1006 if (selector
!= NULL
)
1007 *selector
= nselector
;
1013 parse_method (char *method
, char *type
, char **class,
1014 char **category
, char **selector
)
1018 int found_quote
= 0;
1021 char *nclass
= NULL
;
1022 char *ncategory
= NULL
;
1023 char *nselector
= NULL
;
1025 gdb_assert (type
!= NULL
);
1026 gdb_assert (class != NULL
);
1027 gdb_assert (category
!= NULL
);
1028 gdb_assert (selector
!= NULL
);
1032 while (isspace (*s1
))
1039 while (isspace (*s1
))
1042 if ((s1
[0] == '+') || (s1
[0] == '-'))
1045 while (isspace (*s1
))
1053 while (isalnum (*s1
) || (*s1
== '_'))
1057 while (isspace (*s2
))
1063 while (isspace (*s2
))
1066 while (isalnum (*s2
) || (*s2
== '_'))
1071 /* Truncate the class name now that we're not using the open paren. */
1078 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1080 else if (isspace (*s2
))
1082 else if (*s2
== ']')
1091 while (isspace (*s2
))
1098 while (isspace (*s2
))
1106 if (category
!= NULL
)
1107 *category
= ncategory
;
1108 if (selector
!= NULL
)
1109 *selector
= nselector
;
1115 find_methods (struct symtab
*symtab
, char type
,
1116 const char *class, const char *category
,
1117 const char *selector
, struct symbol
**syms
,
1118 unsigned int *nsym
, unsigned int *ndebug
)
1120 struct objfile
*objfile
= NULL
;
1121 struct minimal_symbol
*msymbol
= NULL
;
1122 struct block
*block
= NULL
;
1123 struct symbol
*sym
= NULL
;
1125 char *symname
= NULL
;
1128 char *nclass
= NULL
;
1129 char *ncategory
= NULL
;
1130 char *nselector
= NULL
;
1132 unsigned int csym
= 0;
1133 unsigned int cdebug
= 0;
1135 static char *tmp
= NULL
;
1136 static unsigned int tmplen
= 0;
1138 gdb_assert (nsym
!= NULL
);
1139 gdb_assert (ndebug
!= NULL
);
1142 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1144 ALL_MSYMBOLS (objfile
, msymbol
)
1148 if ((msymbol
->type
!= mst_text
) && (msymbol
->type
!= mst_file_text
))
1149 /* Not a function or method. */
1153 if ((SYMBOL_VALUE_ADDRESS (msymbol
) < BLOCK_START (block
)) ||
1154 (SYMBOL_VALUE_ADDRESS (msymbol
) >= BLOCK_END (block
)))
1155 /* Not in the specified symtab. */
1158 symname
= SYMBOL_NATURAL_NAME (msymbol
);
1159 if (symname
== NULL
)
1162 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1163 /* Not a method name. */
1166 while ((strlen (symname
) + 1) >= tmplen
)
1168 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1169 tmp
= xrealloc (tmp
, tmplen
);
1171 strcpy (tmp
, symname
);
1173 if (parse_method (tmp
, &ntype
, &nclass
, &ncategory
, &nselector
) == NULL
)
1176 if ((type
!= '\0') && (ntype
!= type
))
1180 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1183 if ((category
!= NULL
) &&
1184 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1187 if ((selector
!= NULL
) &&
1188 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1191 sym
= find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol
));
1194 const char *newsymname
= SYMBOL_NATURAL_NAME (sym
);
1196 if (strcmp (symname
, newsymname
) == 0)
1198 /* Found a high-level method sym: swap it into the
1199 lower part of sym_arr (below num_debuggable). */
1202 syms
[csym
] = syms
[cdebug
];
1211 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1212 newsymname
, symname
);
1214 syms
[csym
] = (struct symbol
*) msymbol
;
1220 /* Found a non-debuggable method symbol. */
1222 syms
[csym
] = (struct symbol
*) msymbol
;
1233 char *find_imps (struct symtab
*symtab
, struct block
*block
,
1234 char *method
, struct symbol
**syms
,
1235 unsigned int *nsym
, unsigned int *ndebug
)
1239 char *category
= NULL
;
1240 char *selector
= NULL
;
1242 unsigned int csym
= 0;
1243 unsigned int cdebug
= 0;
1245 unsigned int ncsym
= 0;
1246 unsigned int ncdebug
= 0;
1251 gdb_assert (nsym
!= NULL
);
1252 gdb_assert (ndebug
!= NULL
);
1259 buf
= (char *) alloca (strlen (method
) + 1);
1260 strcpy (buf
, method
);
1261 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1265 struct symbol
*sym
= NULL
;
1266 struct minimal_symbol
*msym
= NULL
;
1268 strcpy (buf
, method
);
1269 tmp
= parse_selector (buf
, &selector
);
1274 sym
= lookup_symbol (selector
, block
, VAR_DOMAIN
, 0, NULL
);
1284 msym
= lookup_minimal_symbol (selector
, 0, 0);
1289 syms
[csym
] = (struct symbol
*)msym
;
1295 find_methods (symtab
, type
, class, category
, selector
,
1296 syms
+ csym
, &ncsym
, &ncdebug
);
1298 find_methods (symtab
, type
, class, category
, selector
,
1299 NULL
, &ncsym
, &ncdebug
);
1301 /* If we didn't find any methods, just return. */
1302 if (ncsym
== 0 && ncdebug
== 0)
1305 /* Take debug symbols from the second batch of symbols and swap them
1306 * with debug symbols from the first batch. Repeat until either the
1307 * second section is out of debug symbols or the first section is
1308 * full of debug symbols. Either way we have all debug symbols
1309 * packed to the beginning of the buffer.
1314 while ((cdebug
< csym
) && (ncdebug
> 0))
1316 struct symbol
*s
= NULL
;
1317 /* First non-debugging symbol. */
1318 unsigned int i
= cdebug
;
1319 /* Last of second batch of debug symbols. */
1320 unsigned int j
= csym
+ ncdebug
- 1;
1326 /* We've moved a symbol from the second debug section to the
1342 return method
+ (tmp
- buf
);
1346 /* Sort debuggable symbols. */
1348 qsort (syms
, cdebug
, sizeof (struct minimal_symbol
*),
1351 /* Sort minimal_symbols. */
1352 if ((csym
- cdebug
) > 1)
1353 qsort (&syms
[cdebug
], csym
- cdebug
,
1354 sizeof (struct minimal_symbol
*), compare_classes
);
1356 /* Terminate the sym_arr list. */
1359 return method
+ (tmp
- buf
);
1363 print_object_command (char *args
, int from_tty
)
1365 struct value
*object
, *function
, *description
;
1366 CORE_ADDR string_addr
, object_addr
;
1370 if (!args
|| !*args
)
1372 "The 'print-object' command requires an argument (an Objective-C object)");
1375 struct expression
*expr
= parse_expression (args
);
1376 struct cleanup
*old_chain
=
1377 make_cleanup (free_current_contents
, &expr
);
1380 object
= expr
->language_defn
->la_exp_desc
->evaluate_exp
1381 (builtin_type_void_data_ptr
, expr
, &pc
, EVAL_NORMAL
);
1382 do_cleanups (old_chain
);
1385 /* Validate the address for sanity. */
1386 object_addr
= value_as_long (object
);
1387 read_memory (object_addr
, &c
, 1);
1389 function
= find_function_in_inferior ("_NSPrintForDebugger");
1390 if (function
== NULL
)
1391 error (_("Unable to locate _NSPrintForDebugger in child process"));
1393 description
= call_function_by_hand (function
, 1, &object
);
1395 string_addr
= value_as_long (description
);
1396 if (string_addr
== 0)
1397 error (_("object returns null description"));
1399 read_memory (string_addr
+ i
++, &c
, 1);
1402 { /* Read and print characters up to EOS. */
1404 printf_filtered ("%c", c
);
1405 read_memory (string_addr
+ i
++, &c
, 1);
1408 printf_filtered(_("<object returns empty description>"));
1409 printf_filtered ("\n");
1412 /* The data structure 'methcalls' is used to detect method calls (thru
1413 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1414 * and ultimately find the method being called.
1417 struct objc_methcall
{
1419 /* Return instance method to be called. */
1420 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1421 /* Start of pc range corresponding to method invocation. */
1423 /* End of pc range corresponding to method invocation. */
1427 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1428 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1429 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1430 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1432 static struct objc_methcall methcalls
[] = {
1433 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1434 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1435 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1436 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1437 { "_objc_getClass", NULL
, 0, 0},
1438 { "_objc_getMetaClass", NULL
, 0, 0}
1441 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1443 /* The following function, "find_objc_msgsend", fills in the data
1444 * structure "objc_msgs" by finding the addresses of each of the
1445 * (currently four) functions that it holds (of which objc_msgSend is
1446 * the first). This must be called each time symbols are loaded, in
1447 * case the functions have moved for some reason.
1451 find_objc_msgsend (void)
1454 for (i
= 0; i
< nmethcalls
; i
++) {
1456 struct minimal_symbol
*func
;
1458 /* Try both with and without underscore. */
1459 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1460 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_')) {
1461 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1464 methcalls
[i
].begin
= 0;
1465 methcalls
[i
].end
= 0;
1469 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1471 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1472 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
1476 /* find_objc_msgcall (replaces pc_off_limits)
1478 * ALL that this function now does is to determine whether the input
1479 * address ("pc") is the address of one of the Objective-C message
1480 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1481 * if so, it returns the address of the method that will be called.
1483 * The old function "pc_off_limits" used to do a lot of other things
1484 * in addition, such as detecting shared library jump stubs and
1485 * returning the address of the shlib function that would be called.
1486 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1487 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1488 * dependent modules.
1491 struct objc_submethod_helper_data
{
1492 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1498 find_objc_msgcall_submethod_helper (void * arg
)
1500 struct objc_submethod_helper_data
*s
=
1501 (struct objc_submethod_helper_data
*) arg
;
1503 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1510 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1514 struct objc_submethod_helper_data s
;
1520 if (catch_errors (find_objc_msgcall_submethod_helper
,
1522 "Unable to determine target of Objective-C method call (ignoring):\n",
1523 RETURN_MASK_ALL
) == 0)
1530 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1534 find_objc_msgsend ();
1540 for (i
= 0; i
< nmethcalls
; i
++)
1541 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1543 if (methcalls
[i
].stop_at
!= NULL
)
1544 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1553 extern initialize_file_ftype _initialize_objc_language
; /* -Wmissing-prototypes */
1556 _initialize_objc_language (void)
1558 add_language (&objc_language_defn
);
1559 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1560 _("All Objective-C selectors, or those matching REGEXP."));
1561 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1562 _("All Objective-C classes, or those matching REGEXP."));
1563 add_com ("print-object", class_vars
, print_object_command
,
1564 _("Ask an Objective-C object to print itself."));
1565 add_com_alias ("po", "print-object", class_vars
, 1);
1569 read_objc_method (CORE_ADDR addr
, struct objc_method
*method
)
1571 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4);
1572 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4);
1573 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4);
1577 unsigned long read_objc_methlist_nmethods (CORE_ADDR addr
)
1579 return read_memory_unsigned_integer (addr
+ 4, 4);
1583 read_objc_methlist_method (CORE_ADDR addr
, unsigned long num
,
1584 struct objc_method
*method
)
1586 gdb_assert (num
< read_objc_methlist_nmethods (addr
));
1587 read_objc_method (addr
+ 8 + (12 * num
), method
);
1591 read_objc_object (CORE_ADDR addr
, struct objc_object
*object
)
1593 object
->isa
= read_memory_unsigned_integer (addr
, 4);
1597 read_objc_super (CORE_ADDR addr
, struct objc_super
*super
)
1599 super
->receiver
= read_memory_unsigned_integer (addr
, 4);
1600 super
->class = read_memory_unsigned_integer (addr
+ 4, 4);
1604 read_objc_class (CORE_ADDR addr
, struct objc_class
*class)
1606 class->isa
= read_memory_unsigned_integer (addr
, 4);
1607 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4);
1608 class->name
= read_memory_unsigned_integer (addr
+ 8, 4);
1609 class->version
= read_memory_unsigned_integer (addr
+ 12, 4);
1610 class->info
= read_memory_unsigned_integer (addr
+ 16, 4);
1611 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4);
1612 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4);
1613 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4);
1614 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4);
1615 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4);
1619 find_implementation_from_class (CORE_ADDR
class, CORE_ADDR sel
)
1621 CORE_ADDR subclass
= class;
1623 while (subclass
!= 0)
1626 struct objc_class class_str
;
1627 unsigned mlistnum
= 0;
1629 read_objc_class (subclass
, &class_str
);
1634 unsigned long nmethods
;
1637 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1642 nmethods
= read_objc_methlist_nmethods (mlist
);
1644 for (i
= 0; i
< nmethods
; i
++)
1646 struct objc_method meth_str
;
1647 read_objc_methlist_method (mlist
, i
, &meth_str
);
1651 "checking method 0x%lx against selector 0x%lx\n",
1652 meth_str
.name
, sel
);
1655 if (meth_str
.name
== sel
)
1656 /* FIXME: hppa arch was doing a pointer dereference
1657 here. There needs to be a better way to do that. */
1658 return meth_str
.imp
;
1662 subclass
= class_str
.super_class
;
1669 find_implementation (CORE_ADDR object
, CORE_ADDR sel
)
1671 struct objc_object ostr
;
1675 read_objc_object (object
, &ostr
);
1679 return find_implementation_from_class (ostr
.isa
, sel
);
1682 #define OBJC_FETCH_POINTER_ARGUMENT(argi) \
1683 gdbarch_fetch_pointer_argument (current_gdbarch, get_current_frame (), \
1684 argi, builtin_type_void_func_ptr)
1687 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1693 object
= OBJC_FETCH_POINTER_ARGUMENT (0);
1694 sel
= OBJC_FETCH_POINTER_ARGUMENT (1);
1696 res
= find_implementation (object
, sel
);
1705 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1711 object
= OBJC_FETCH_POINTER_ARGUMENT (1);
1712 sel
= OBJC_FETCH_POINTER_ARGUMENT (2);
1714 res
= find_implementation (object
, sel
);
1723 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1725 struct objc_super sstr
;
1731 super
= OBJC_FETCH_POINTER_ARGUMENT (0);
1732 sel
= OBJC_FETCH_POINTER_ARGUMENT (1);
1734 read_objc_super (super
, &sstr
);
1735 if (sstr
.class == 0)
1738 res
= find_implementation_from_class (sstr
.class, sel
);
1747 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1749 struct objc_super sstr
;
1755 super
= OBJC_FETCH_POINTER_ARGUMENT (1);
1756 sel
= OBJC_FETCH_POINTER_ARGUMENT (2);
1758 read_objc_super (super
, &sstr
);
1759 if (sstr
.class == 0)
1762 res
= find_implementation_from_class (sstr
.class, sel
);