1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Apple Computer, Inc.
7 Written by Michael Snyder.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "expression.h"
28 #include "parser-defs.h"
31 #include "objc-lang.h"
32 #include "exceptions.h"
33 #include "complaints.h"
37 #include "gdb_string.h" /* for strchr */
38 #include "target.h" /* for target_has_execution */
42 #include "gdb_regex.h"
47 #include "gdb_assert.h"
57 CORE_ADDR super_class;
79 static const struct objfile_data *objc_objfile_data;
81 /* Lookup a structure type named "struct NAME", visible in lexical
82 block BLOCK. If NOERR is nonzero, return zero if NAME is not
86 lookup_struct_typedef (char *name, struct block *block, int noerr)
90 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
97 error (_("No struct type named %s."), name);
99 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
104 error (_("This context has class, union or enum %s, not a struct."),
111 lookup_objc_class (struct gdbarch *gdbarch, char *classname)
113 struct type *char_type = builtin_type (gdbarch)->builtin_char;
114 struct value * function, *classval;
116 if (! target_has_execution)
118 /* Can't call into inferior to lookup class. */
122 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
123 function = find_function_in_inferior("objc_lookUpClass", NULL);
124 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
125 function = find_function_in_inferior("objc_lookup_class", NULL);
128 complaint (&symfile_complaints, _("no way to lookup Objective-C classes"));
132 classval = value_string (classname, strlen (classname) + 1, char_type);
133 classval = value_coerce_array (classval);
134 return (CORE_ADDR) value_as_long (call_function_by_hand (function,
139 lookup_child_selector (struct gdbarch *gdbarch, char *selname)
141 struct type *char_type = builtin_type (gdbarch)->builtin_char;
142 struct value * function, *selstring;
144 if (! target_has_execution)
146 /* Can't call into inferior to lookup selector. */
150 if (lookup_minimal_symbol("sel_getUid", 0, 0))
151 function = find_function_in_inferior("sel_getUid", NULL);
152 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
153 function = find_function_in_inferior("sel_get_any_uid", NULL);
156 complaint (&symfile_complaints, _("no way to lookup Objective-C selectors"));
160 selstring = value_coerce_array (value_string (selname,
161 strlen (selname) + 1, char_type));
162 return value_as_long (call_function_by_hand (function, 1, &selstring));
166 value_nsstring (struct gdbarch *gdbarch, char *ptr, int len)
168 struct type *char_type = builtin_type (gdbarch)->builtin_char;
169 struct value *stringValue[3];
170 struct value *function, *nsstringValue;
174 if (!target_has_execution)
175 return 0; /* Can't call into inferior to create NSString. */
177 stringValue[2] = value_string(ptr, len, char_type);
178 stringValue[2] = value_coerce_array(stringValue[2]);
179 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
180 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
182 function = find_function_in_inferior("_NSNewStringFromCString", NULL);
183 nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
185 else if (lookup_minimal_symbol("istr", 0, 0))
187 function = find_function_in_inferior("istr", NULL);
188 nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
190 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
193 = find_function_in_inferior("+[NSString stringWithCString:]", NULL);
194 type = builtin_type (gdbarch)->builtin_long;
196 stringValue[0] = value_from_longest
197 (type, lookup_objc_class (gdbarch, "NSString"));
198 stringValue[1] = value_from_longest
199 (type, lookup_child_selector (gdbarch, "stringWithCString:"));
200 nsstringValue = call_function_by_hand(function, 3, &stringValue[0]);
203 error (_("NSString: internal error -- no way to create new NSString"));
205 sym = lookup_struct_typedef("NSString", 0, 1);
207 sym = lookup_struct_typedef("NXString", 0, 1);
209 type = builtin_type (gdbarch)->builtin_data_ptr;
211 type = lookup_pointer_type(SYMBOL_TYPE (sym));
213 deprecated_set_value_type (nsstringValue, type);
214 return nsstringValue;
217 /* Objective-C name demangling. */
220 objc_demangle (const char *mangled, int options)
222 char *demangled, *cp;
224 if (mangled[0] == '_' &&
225 (mangled[1] == 'i' || mangled[1] == 'c') &&
228 cp = demangled = xmalloc(strlen(mangled) + 2);
230 if (mangled[1] == 'i')
231 *cp++ = '-'; /* for instance method */
233 *cp++ = '+'; /* for class method */
235 *cp++ = '['; /* opening left brace */
236 strcpy(cp, mangled+3); /* tack on the rest of the mangled name */
238 while (*cp && *cp == '_')
239 cp++; /* skip any initial underbars in class name */
241 cp = strchr(cp, '_');
242 if (!cp) /* find first non-initial underbar */
244 xfree(demangled); /* not mangled name */
247 if (cp[1] == '_') { /* easy case: no category name */
248 *cp++ = ' '; /* replace two '_' with one ' ' */
249 strcpy(cp, mangled + (cp - demangled) + 2);
252 *cp++ = '('; /* less easy case: category name */
253 cp = strchr(cp, '_');
256 xfree(demangled); /* not mangled name */
260 *cp++ = ' '; /* overwriting 1st char of method name... */
261 strcpy(cp, mangled + (cp - demangled)); /* get it back */
264 while (*cp && *cp == '_')
265 cp++; /* skip any initial underbars in method name */
269 *cp = ':'; /* replace remaining '_' with ':' */
271 *cp++ = ']'; /* closing right brace */
272 *cp++ = 0; /* string terminator */
276 return NULL; /* Not an objc mangled name. */
279 /* Print the character C on STREAM as part of the contents of a
280 literal string whose delimiter is QUOTER. Note that that format
281 for printing characters and strings is language specific. */
284 objc_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
287 c &= 0xFF; /* Avoid sign bit follies. */
289 if (PRINT_LITERAL_FORM (c))
291 if (c == '\\' || c == quoter)
293 fputs_filtered ("\\", stream);
295 fprintf_filtered (stream, "%c", c);
302 fputs_filtered ("\\n", stream);
305 fputs_filtered ("\\b", stream);
308 fputs_filtered ("\\t", stream);
311 fputs_filtered ("\\f", stream);
314 fputs_filtered ("\\r", stream);
317 fputs_filtered ("\\e", stream);
320 fputs_filtered ("\\a", stream);
323 fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
330 objc_printchar (int c, struct type *type, struct ui_file *stream)
332 fputs_filtered ("'", stream);
333 objc_emit_char (c, type, stream, '\'');
334 fputs_filtered ("'", stream);
337 /* Print the character string STRING, printing at most LENGTH
338 characters. Printing stops early if the number hits print_max;
339 repeat counts are printed as appropriate. Print ellipses at the
340 end if we had to stop before printing LENGTH characters, or if
344 objc_printstr (struct ui_file *stream, struct type *type,
345 const gdb_byte *string, unsigned int length,
346 const char *encoding, int force_ellipses,
347 const struct value_print_options *options)
350 unsigned int things_printed = 0;
354 /* If the string was not truncated due to `set print elements', and
355 the last byte of it is a null, we don't print that, in
356 traditional C style. */
357 if ((!force_ellipses) && length > 0 && string[length-1] == '\0')
362 fputs_filtered ("\"\"", stream);
366 for (i = 0; i < length && things_printed < options->print_max; ++i)
368 /* Position of the character we are examining to see whether it
371 /* Number of repetitions we have detected so far. */
378 fputs_filtered (", ", stream);
384 while (rep1 < length && string[rep1] == string[i])
390 if (reps > options->repeat_count_threshold)
394 if (options->inspect_it)
395 fputs_filtered ("\\\", ", stream);
397 fputs_filtered ("\", ", stream);
400 objc_printchar (string[i], type, stream);
401 fprintf_filtered (stream, " <repeats %u times>", reps);
403 things_printed += options->repeat_count_threshold;
410 if (options->inspect_it)
411 fputs_filtered ("\\\"", stream);
413 fputs_filtered ("\"", stream);
416 objc_emit_char (string[i], type, stream, '"');
421 /* Terminate the quotes if necessary. */
424 if (options->inspect_it)
425 fputs_filtered ("\\\"", stream);
427 fputs_filtered ("\"", stream);
430 if (force_ellipses || i < length)
431 fputs_filtered ("...", stream);
434 /* Determine if we are currently in the Objective-C dispatch function.
435 If so, get the address of the method function that the dispatcher
436 would call and use that as the function to step into instead. Also
437 skip over the trampoline for the function (if any). This is better
438 for the user since they are only interested in stepping into the
439 method function anyway. */
441 objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
443 struct gdbarch *gdbarch = get_frame_arch (frame);
444 CORE_ADDR real_stop_pc;
445 CORE_ADDR method_stop_pc;
447 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
449 if (real_stop_pc != 0)
450 find_objc_msgcall (real_stop_pc, &method_stop_pc);
452 find_objc_msgcall (stop_pc, &method_stop_pc);
456 real_stop_pc = gdbarch_skip_trampoline_code
457 (gdbarch, frame, method_stop_pc);
458 if (real_stop_pc == 0)
459 real_stop_pc = method_stop_pc;
466 /* Table mapping opcodes into strings for printing operators
467 and precedences of the operators. */
469 static const struct op_print objc_op_print_tab[] =
471 {",", BINOP_COMMA, PREC_COMMA, 0},
472 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
473 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
474 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
475 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
476 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
477 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
478 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
479 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
480 {"<=", BINOP_LEQ, PREC_ORDER, 0},
481 {">=", BINOP_GEQ, PREC_ORDER, 0},
482 {">", BINOP_GTR, PREC_ORDER, 0},
483 {"<", BINOP_LESS, PREC_ORDER, 0},
484 {">>", BINOP_RSH, PREC_SHIFT, 0},
485 {"<<", BINOP_LSH, PREC_SHIFT, 0},
486 {"+", BINOP_ADD, PREC_ADD, 0},
487 {"-", BINOP_SUB, PREC_ADD, 0},
488 {"*", BINOP_MUL, PREC_MUL, 0},
489 {"/", BINOP_DIV, PREC_MUL, 0},
490 {"%", BINOP_REM, PREC_MUL, 0},
491 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
492 {"-", UNOP_NEG, PREC_PREFIX, 0},
493 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
494 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
495 {"*", UNOP_IND, PREC_PREFIX, 0},
496 {"&", UNOP_ADDR, PREC_PREFIX, 0},
497 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
498 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
499 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
500 {NULL, OP_NULL, PREC_NULL, 0}
503 const struct language_defn objc_language_defn = {
504 "objective-c", /* Language name */
511 &exp_descriptor_standard,
515 objc_printchar, /* Print a character constant */
516 objc_printstr, /* Function to print string constant */
518 c_print_type, /* Print a type using appropriate syntax */
519 c_print_typedef, /* Print a typedef using appropriate syntax */
520 c_val_print, /* Print a value using appropriate syntax */
521 c_value_print, /* Print a top-level value */
522 objc_skip_trampoline, /* Language specific skip_trampoline */
523 "self", /* name_of_this */
524 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
525 basic_lookup_transparent_type,/* lookup_transparent_type */
526 objc_demangle, /* Language specific symbol demangler */
527 NULL, /* Language specific class_name_from_physname */
528 objc_op_print_tab, /* Expression operators for printing */
529 1, /* C-style arrays */
530 0, /* String lower bound */
531 default_word_break_characters,
532 default_make_symbol_completion_list,
533 c_language_arch_info,
534 default_print_array_index,
535 default_pass_by_reference,
542 * Following functions help construct Objective-C message calls
545 struct selname /* For parsing Objective-C. */
547 struct selname *next;
552 static int msglist_len;
553 static struct selname *selname_chain;
554 static char *msglist_sel;
559 struct selname *new =
560 (struct selname *) xmalloc (sizeof (struct selname));
562 new->next = selname_chain;
563 new->msglist_len = msglist_len;
564 new->msglist_sel = msglist_sel;
566 msglist_sel = (char *)xmalloc(1);
572 add_msglist(struct stoken *str, int addcolon)
577 if (str == 0) { /* Unnamed arg, or... */
578 if (addcolon == 0) { /* variable number of args. */
588 len = plen + strlen(msglist_sel) + 2;
589 s = (char *)xmalloc(len);
590 strcpy(s, msglist_sel);
605 int val = msglist_len;
606 struct selname *sel = selname_chain;
607 char *p = msglist_sel;
610 selname_chain = sel->next;
611 msglist_len = sel->msglist_len;
612 msglist_sel = sel->msglist_sel;
613 selid = lookup_child_selector (parse_gdbarch, p);
615 error (_("Can't find selector \"%s\""), p);
616 write_exp_elt_longcst (selid);
618 write_exp_elt_longcst (val); /* Number of args */
625 * Function: specialcmp (char *a, char *b)
627 * Special strcmp: treats ']' and ' ' as end-of-string.
628 * Used for qsorting lists of objc methods (either by class or selector).
632 specialcmp (char *a, char *b)
634 while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']')
640 if (*a && *a != ' ' && *a != ']')
641 return 1; /* a is longer therefore greater */
642 if (*b && *b != ' ' && *b != ']')
643 return -1; /* a is shorter therefore lesser */
644 return 0; /* a and b are identical */
648 * Function: compare_selectors (const void *, const void *)
650 * Comparison function for use with qsort. Arguments are symbols or
651 * msymbols Compares selector part of objc method name alphabetically.
655 compare_selectors (const void *a, const void *b)
659 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
660 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
661 if (aname == NULL || bname == NULL)
662 error (_("internal: compare_selectors(1)"));
664 aname = strchr(aname, ' ');
665 bname = strchr(bname, ' ');
666 if (aname == NULL || bname == NULL)
667 error (_("internal: compare_selectors(2)"));
669 return specialcmp (aname+1, bname+1);
673 * Function: selectors_info (regexp, from_tty)
675 * Implements the "Info selectors" command. Takes an optional regexp
676 * arg. Lists all objective c selectors that match the regexp. Works
677 * by grepping thru all symbols for objective c methods. Output list
678 * is sorted and uniqued.
682 selectors_info (char *regexp, int from_tty)
684 struct objfile *objfile;
685 struct minimal_symbol *msymbol;
693 struct symbol **sym_arr;
697 strcpy(myregexp, ".*]"); /* Null input, match all objc methods. */
700 if (*regexp == '+' || *regexp == '-')
701 { /* User wants only class methods or only instance methods. */
702 plusminus = *regexp++;
703 while (*regexp == ' ' || *regexp == '\t')
707 strcpy(myregexp, ".*]");
710 strcpy(myregexp, regexp);
711 if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
712 myregexp[strlen(myregexp) - 1] = ']'; /* end of method name */
714 strcat(myregexp, ".*]");
720 val = re_comp (myregexp);
722 error (_("Invalid regexp (%s): %s"), val, regexp);
725 /* First time thru is JUST to get max length and count. */
726 ALL_MSYMBOLS (objfile, msymbol)
729 name = SYMBOL_NATURAL_NAME (msymbol);
731 (name[0] == '-' || name[0] == '+') &&
732 name[1] == '[') /* Got a method name. */
734 /* Filter for class/instance methods. */
735 if (plusminus && name[0] != plusminus)
737 /* Find selector part. */
738 name = (char *) strchr(name+2, ' ');
739 if (regexp == NULL || re_exec(++name) != 0)
741 char *mystart = name;
742 char *myend = (char *) strchr(mystart, ']');
744 if (myend && (myend - mystart > maxlen))
745 maxlen = myend - mystart; /* Get longest selector. */
752 printf_filtered (_("Selectors matching \"%s\":\n\n"),
753 regexp ? regexp : "*");
755 sym_arr = alloca (matches * sizeof (struct symbol *));
757 ALL_MSYMBOLS (objfile, msymbol)
760 name = SYMBOL_NATURAL_NAME (msymbol);
762 (name[0] == '-' || name[0] == '+') &&
763 name[1] == '[') /* Got a method name. */
765 /* Filter for class/instance methods. */
766 if (plusminus && name[0] != plusminus)
768 /* Find selector part. */
769 name = (char *) strchr(name+2, ' ');
770 if (regexp == NULL || re_exec(++name) != 0)
771 sym_arr[matches++] = (struct symbol *) msymbol;
775 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
777 /* Prevent compare on first iteration. */
779 for (ix = 0; ix < matches; ix++) /* Now do the output. */
784 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
785 name = strchr (name, ' ') + 1;
786 if (p[0] && specialcmp(name, p) == 0)
787 continue; /* Seen this one already (not unique). */
789 /* Copy selector part. */
790 while (*name && *name != ']')
793 /* Print in columns. */
794 puts_filtered_tabular(asel, maxlen + 1, 0);
799 printf_filtered (_("No selectors matching \"%s\"\n"), regexp ? regexp : "*");
803 * Function: compare_classes (const void *, const void *)
805 * Comparison function for use with qsort. Arguments are symbols or
806 * msymbols Compares class part of objc method name alphabetically.
810 compare_classes (const void *a, const void *b)
814 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
815 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
816 if (aname == NULL || bname == NULL)
817 error (_("internal: compare_classes(1)"));
819 return specialcmp (aname+1, bname+1);
823 * Function: classes_info(regexp, from_tty)
825 * Implements the "info classes" command for objective c classes.
826 * Lists all objective c classes that match the optional regexp.
827 * Works by grepping thru the list of objective c methods. List will
828 * be sorted and uniqued (since one class may have many methods).
829 * BUGS: will not list a class that has no methods.
833 classes_info (char *regexp, int from_tty)
835 struct objfile *objfile;
836 struct minimal_symbol *msymbol;
844 struct symbol **sym_arr;
847 strcpy(myregexp, ".* "); /* Null input: match all objc classes. */
850 strcpy(myregexp, regexp);
851 if (myregexp[strlen(myregexp) - 1] == '$')
852 /* In the method name, the end of the class name is marked by ' '. */
853 myregexp[strlen(myregexp) - 1] = ' ';
855 strcat(myregexp, ".* ");
860 val = re_comp (myregexp);
862 error (_("Invalid regexp (%s): %s"), val, regexp);
865 /* First time thru is JUST to get max length and count. */
866 ALL_MSYMBOLS (objfile, msymbol)
869 name = SYMBOL_NATURAL_NAME (msymbol);
871 (name[0] == '-' || name[0] == '+') &&
872 name[1] == '[') /* Got a method name. */
873 if (regexp == NULL || re_exec(name+2) != 0)
875 /* Compute length of classname part. */
876 char *mystart = name + 2;
877 char *myend = (char *) strchr(mystart, ' ');
879 if (myend && (myend - mystart > maxlen))
880 maxlen = myend - mystart;
886 printf_filtered (_("Classes matching \"%s\":\n\n"),
887 regexp ? regexp : "*");
888 sym_arr = alloca (matches * sizeof (struct symbol *));
890 ALL_MSYMBOLS (objfile, msymbol)
893 name = SYMBOL_NATURAL_NAME (msymbol);
895 (name[0] == '-' || name[0] == '+') &&
896 name[1] == '[') /* Got a method name. */
897 if (regexp == NULL || re_exec(name+2) != 0)
898 sym_arr[matches++] = (struct symbol *) msymbol;
901 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
903 /* Prevent compare on first iteration. */
905 for (ix = 0; ix < matches; ix++) /* Now do the output. */
910 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
912 if (p[0] && specialcmp(name, p) == 0)
913 continue; /* Seen this one already (not unique). */
915 /* Copy class part of method name. */
916 while (*name && *name != ' ')
919 /* Print in columns. */
920 puts_filtered_tabular(aclass, maxlen + 1, 0);
925 printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*");
929 * Function: find_imps (char *selector, struct symbol **sym_arr)
931 * Input: a string representing a selector
932 * a pointer to an array of symbol pointers
933 * possibly a pointer to a symbol found by the caller.
935 * Output: number of methods that implement that selector. Side
936 * effects: The array of symbol pointers is filled with matching syms.
938 * By analogy with function "find_methods" (symtab.c), builds a list
939 * of symbols matching the ambiguous input, so that "decode_line_2"
940 * (symtab.c) can list them and ask the user to choose one or more.
941 * In this case the matches are objective c methods
942 * ("implementations") matching an objective c selector.
944 * Note that it is possible for a normal (c-style) function to have
945 * the same name as an objective c selector. To prevent the selector
946 * from eclipsing the function, we allow the caller (decode_line_1) to
947 * search for such a function first, and if it finds one, pass it in
948 * to us. We will then integrate it into the list. We also search
949 * for one here, among the minsyms.
951 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
952 * into two parts: debuggable (struct symbol) syms, and
953 * non_debuggable (struct minimal_symbol) syms. The debuggable
954 * ones will come first, before NUM_DEBUGGABLE (which will thus
955 * be the index of the first non-debuggable one).
959 * Function: total_number_of_imps (char *selector);
961 * Input: a string representing a selector
962 * Output: number of methods that implement that selector.
964 * By analogy with function "total_number_of_methods", this allows
965 * decode_line_1 (symtab.c) to detect if there are objective c methods
966 * matching the input, and to allocate an array of pointers to them
967 * which can be manipulated by "decode_line_2" (also in symtab.c).
971 parse_selector (char *method, char **selector)
977 char *nselector = NULL;
979 gdb_assert (selector != NULL);
983 while (isspace (*s1))
990 while (isspace (*s1))
997 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
999 else if (isspace (*s2))
1001 else if ((*s2 == '\0') || (*s2 == '\''))
1009 while (isspace (*s2))
1015 while (isspace (*s2))
1019 if (selector != NULL)
1020 *selector = nselector;
1026 parse_method (char *method, char *type, char **class,
1027 char **category, char **selector)
1031 int found_quote = 0;
1034 char *nclass = NULL;
1035 char *ncategory = NULL;
1036 char *nselector = NULL;
1038 gdb_assert (type != NULL);
1039 gdb_assert (class != NULL);
1040 gdb_assert (category != NULL);
1041 gdb_assert (selector != NULL);
1045 while (isspace (*s1))
1052 while (isspace (*s1))
1055 if ((s1[0] == '+') || (s1[0] == '-'))
1058 while (isspace (*s1))
1066 while (isalnum (*s1) || (*s1 == '_'))
1070 while (isspace (*s2))
1076 while (isspace (*s2))
1079 while (isalnum (*s2) || (*s2 == '_'))
1084 /* Truncate the class name now that we're not using the open paren. */
1091 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1093 else if (isspace (*s2))
1095 else if (*s2 == ']')
1104 while (isspace (*s2))
1111 while (isspace (*s2))
1119 if (category != NULL)
1120 *category = ncategory;
1121 if (selector != NULL)
1122 *selector = nselector;
1128 find_methods (struct symtab *symtab, char type,
1129 const char *class, const char *category,
1130 const char *selector, struct symbol **syms,
1131 unsigned int *nsym, unsigned int *ndebug)
1133 struct objfile *objfile = NULL;
1134 struct minimal_symbol *msymbol = NULL;
1135 struct block *block = NULL;
1136 struct symbol *sym = NULL;
1138 char *symname = NULL;
1141 char *nclass = NULL;
1142 char *ncategory = NULL;
1143 char *nselector = NULL;
1145 unsigned int csym = 0;
1146 unsigned int cdebug = 0;
1148 static char *tmp = NULL;
1149 static unsigned int tmplen = 0;
1151 gdb_assert (nsym != NULL);
1152 gdb_assert (ndebug != NULL);
1155 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1157 ALL_OBJFILES (objfile)
1159 unsigned int *objc_csym;
1161 /* The objfile_csym variable counts the number of ObjC methods
1162 that this objfile defines. We save that count as a private
1163 objfile data. If we have already determined that this objfile
1164 provides no ObjC methods, we can skip it entirely. */
1166 unsigned int objfile_csym = 0;
1168 objc_csym = objfile_data (objfile, objc_objfile_data);
1169 if (objc_csym != NULL && *objc_csym == 0)
1170 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1173 ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
1175 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1176 CORE_ADDR pc = SYMBOL_VALUE_ADDRESS (msymbol);
1180 /* Check the symbol name first as this can be done entirely without
1181 sending any query to the target. */
1182 symname = SYMBOL_NATURAL_NAME (msymbol);
1183 if (symname == NULL)
1186 if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1187 /* Not a method name. */
1190 /* The minimal symbol might point to a function descriptor;
1191 resolve it to the actual code address instead. */
1192 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, pc,
1196 if (pc < BLOCK_START (block) || pc >= BLOCK_END (block))
1197 /* Not in the specified symtab. */
1200 /* Now that thinks are a bit sane, clean up the symname. */
1201 while ((strlen (symname) + 1) >= tmplen)
1203 tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1204 tmp = xrealloc (tmp, tmplen);
1206 strcpy (tmp, symname);
1208 if (parse_method (tmp, &ntype, &nclass, &ncategory, &nselector) == NULL)
1213 if ((type != '\0') && (ntype != type))
1217 && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1220 if ((category != NULL) &&
1221 ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1224 if ((selector != NULL) &&
1225 ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1228 sym = find_pc_function (pc);
1231 const char *newsymname = SYMBOL_NATURAL_NAME (sym);
1233 if (strcmp (symname, newsymname) == 0)
1235 /* Found a high-level method sym: swap it into the
1236 lower part of sym_arr (below num_debuggable). */
1239 syms[csym] = syms[cdebug];
1248 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1249 newsymname, symname);
1251 syms[csym] = (struct symbol *) msymbol;
1257 /* Found a non-debuggable method symbol. */
1259 syms[csym] = (struct symbol *) msymbol;
1263 if (objc_csym == NULL)
1265 objc_csym = obstack_alloc (&objfile->objfile_obstack,
1266 sizeof (*objc_csym));
1267 *objc_csym = objfile_csym;
1268 set_objfile_data (objfile, objc_objfile_data, objc_csym);
1271 /* Count of ObjC methods in this objfile should be constant. */
1272 gdb_assert (*objc_csym == objfile_csym);
1281 char *find_imps (struct symtab *symtab, struct block *block,
1282 char *method, struct symbol **syms,
1283 unsigned int *nsym, unsigned int *ndebug)
1287 char *category = NULL;
1288 char *selector = NULL;
1290 unsigned int csym = 0;
1291 unsigned int cdebug = 0;
1293 unsigned int ncsym = 0;
1294 unsigned int ncdebug = 0;
1299 gdb_assert (nsym != NULL);
1300 gdb_assert (ndebug != NULL);
1307 buf = (char *) alloca (strlen (method) + 1);
1308 strcpy (buf, method);
1309 tmp = parse_method (buf, &type, &class, &category, &selector);
1313 struct symbol *sym = NULL;
1314 struct minimal_symbol *msym = NULL;
1316 strcpy (buf, method);
1317 tmp = parse_selector (buf, &selector);
1322 sym = lookup_symbol (selector, block, VAR_DOMAIN, 0);
1332 msym = lookup_minimal_symbol (selector, 0, 0);
1337 syms[csym] = (struct symbol *)msym;
1343 find_methods (symtab, type, class, category, selector,
1344 syms + csym, &ncsym, &ncdebug);
1346 find_methods (symtab, type, class, category, selector,
1347 NULL, &ncsym, &ncdebug);
1349 /* If we didn't find any methods, just return. */
1350 if (ncsym == 0 && ncdebug == 0)
1353 /* Take debug symbols from the second batch of symbols and swap them
1354 * with debug symbols from the first batch. Repeat until either the
1355 * second section is out of debug symbols or the first section is
1356 * full of debug symbols. Either way we have all debug symbols
1357 * packed to the beginning of the buffer.
1362 while ((cdebug < csym) && (ncdebug > 0))
1364 struct symbol *s = NULL;
1365 /* First non-debugging symbol. */
1366 unsigned int i = cdebug;
1367 /* Last of second batch of debug symbols. */
1368 unsigned int j = csym + ncdebug - 1;
1374 /* We've moved a symbol from the second debug section to the
1390 return method + (tmp - buf);
1394 /* Sort debuggable symbols. */
1396 qsort (syms, cdebug, sizeof (struct minimal_symbol *),
1399 /* Sort minimal_symbols. */
1400 if ((csym - cdebug) > 1)
1401 qsort (&syms[cdebug], csym - cdebug,
1402 sizeof (struct minimal_symbol *), compare_classes);
1404 /* Terminate the sym_arr list. */
1407 return method + (tmp - buf);
1411 print_object_command (char *args, int from_tty)
1413 struct value *object, *function, *description;
1414 CORE_ADDR string_addr, object_addr;
1418 if (!args || !*args)
1420 "The 'print-object' command requires an argument (an Objective-C object)");
1423 struct expression *expr = parse_expression (args);
1424 struct cleanup *old_chain =
1425 make_cleanup (free_current_contents, &expr);
1428 object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1429 expr, &pc, EVAL_NORMAL);
1430 do_cleanups (old_chain);
1433 /* Validate the address for sanity. */
1434 object_addr = value_as_long (object);
1435 read_memory (object_addr, &c, 1);
1437 function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1438 if (function == NULL)
1439 error (_("Unable to locate _NSPrintForDebugger in child process"));
1441 description = call_function_by_hand (function, 1, &object);
1443 string_addr = value_as_long (description);
1444 if (string_addr == 0)
1445 error (_("object returns null description"));
1447 read_memory (string_addr + i++, &c, 1);
1450 { /* Read and print characters up to EOS. */
1452 printf_filtered ("%c", c);
1453 read_memory (string_addr + i++, &c, 1);
1456 printf_filtered(_("<object returns empty description>"));
1457 printf_filtered ("\n");
1460 /* The data structure 'methcalls' is used to detect method calls (thru
1461 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1462 * and ultimately find the method being called.
1465 struct objc_methcall {
1467 /* Return instance method to be called. */
1468 int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1469 /* Start of pc range corresponding to method invocation. */
1471 /* End of pc range corresponding to method invocation. */
1475 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1476 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1477 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1478 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1480 static struct objc_methcall methcalls[] = {
1481 { "_objc_msgSend", resolve_msgsend, 0, 0},
1482 { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1483 { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1484 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1485 { "_objc_getClass", NULL, 0, 0},
1486 { "_objc_getMetaClass", NULL, 0, 0}
1489 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1491 /* The following function, "find_objc_msgsend", fills in the data
1492 * structure "objc_msgs" by finding the addresses of each of the
1493 * (currently four) functions that it holds (of which objc_msgSend is
1494 * the first). This must be called each time symbols are loaded, in
1495 * case the functions have moved for some reason.
1499 find_objc_msgsend (void)
1502 for (i = 0; i < nmethcalls; i++) {
1504 struct minimal_symbol *func;
1506 /* Try both with and without underscore. */
1507 func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1508 if ((func == NULL) && (methcalls[i].name[0] == '_')) {
1509 func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1512 methcalls[i].begin = 0;
1513 methcalls[i].end = 0;
1517 methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1519 methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1520 } while (methcalls[i].begin == methcalls[i].end);
1524 /* find_objc_msgcall (replaces pc_off_limits)
1526 * ALL that this function now does is to determine whether the input
1527 * address ("pc") is the address of one of the Objective-C message
1528 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1529 * if so, it returns the address of the method that will be called.
1531 * The old function "pc_off_limits" used to do a lot of other things
1532 * in addition, such as detecting shared library jump stubs and
1533 * returning the address of the shlib function that would be called.
1534 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1535 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1536 * dependent modules.
1539 struct objc_submethod_helper_data {
1540 int (*f) (CORE_ADDR, CORE_ADDR *);
1546 find_objc_msgcall_submethod_helper (void * arg)
1548 struct objc_submethod_helper_data *s =
1549 (struct objc_submethod_helper_data *) arg;
1551 if (s->f (s->pc, s->new_pc) == 0)
1558 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1562 struct objc_submethod_helper_data s;
1568 if (catch_errors (find_objc_msgcall_submethod_helper,
1570 "Unable to determine target of Objective-C method call (ignoring):\n",
1571 RETURN_MASK_ALL) == 0)
1578 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1582 find_objc_msgsend ();
1588 for (i = 0; i < nmethcalls; i++)
1589 if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1591 if (methcalls[i].stop_at != NULL)
1592 return find_objc_msgcall_submethod (methcalls[i].stop_at,
1601 extern initialize_file_ftype _initialize_objc_language; /* -Wmissing-prototypes */
1604 _initialize_objc_language (void)
1606 add_language (&objc_language_defn);
1607 add_info ("selectors", selectors_info, /* INFO SELECTORS command. */
1608 _("All Objective-C selectors, or those matching REGEXP."));
1609 add_info ("classes", classes_info, /* INFO CLASSES command. */
1610 _("All Objective-C classes, or those matching REGEXP."));
1611 add_com ("print-object", class_vars, print_object_command,
1612 _("Ask an Objective-C object to print itself."));
1613 add_com_alias ("po", "print-object", class_vars, 1);
1617 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1618 struct objc_method *method)
1620 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1621 method->name = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1622 method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1623 method->imp = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1626 static unsigned long
1627 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1629 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1630 return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1634 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1635 unsigned long num, struct objc_method *method)
1637 gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1638 read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1642 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1643 struct objc_object *object)
1645 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1646 object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1650 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1651 struct objc_super *super)
1653 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1654 super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1655 super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1659 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1660 struct objc_class *class)
1662 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1663 class->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1664 class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1665 class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1666 class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1667 class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
1668 class->instance_size = read_memory_unsigned_integer (addr + 18, 4, byte_order);
1669 class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1670 class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1671 class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1672 class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1676 find_implementation_from_class (struct gdbarch *gdbarch,
1677 CORE_ADDR class, CORE_ADDR sel)
1679 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1680 CORE_ADDR subclass = class;
1682 while (subclass != 0)
1685 struct objc_class class_str;
1686 unsigned mlistnum = 0;
1688 read_objc_class (gdbarch, subclass, &class_str);
1693 unsigned long nmethods;
1696 mlist = read_memory_unsigned_integer (class_str.methods +
1702 nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1704 for (i = 0; i < nmethods; i++)
1706 struct objc_method meth_str;
1707 read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
1711 "checking method 0x%lx against selector 0x%lx\n",
1712 meth_str.name, sel);
1715 if (meth_str.name == sel)
1716 /* FIXME: hppa arch was doing a pointer dereference
1717 here. There needs to be a better way to do that. */
1718 return meth_str.imp;
1722 subclass = class_str.super_class;
1729 find_implementation (struct gdbarch *gdbarch,
1730 CORE_ADDR object, CORE_ADDR sel)
1732 struct objc_object ostr;
1736 read_objc_object (gdbarch, object, &ostr);
1740 return find_implementation_from_class (gdbarch, ostr.isa, sel);
1744 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1746 struct frame_info *frame = get_current_frame ();
1747 struct gdbarch *gdbarch = get_frame_arch (frame);
1748 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1754 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1755 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1757 res = find_implementation (gdbarch, object, sel);
1766 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1768 struct frame_info *frame = get_current_frame ();
1769 struct gdbarch *gdbarch = get_frame_arch (frame);
1770 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1776 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1777 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1779 res = find_implementation (gdbarch, object, sel);
1788 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1790 struct frame_info *frame = get_current_frame ();
1791 struct gdbarch *gdbarch = get_frame_arch (frame);
1792 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1794 struct objc_super sstr;
1800 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1801 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1803 read_objc_super (gdbarch, super, &sstr);
1804 if (sstr.class == 0)
1807 res = find_implementation_from_class (gdbarch, sstr.class, sel);
1816 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1818 struct frame_info *frame = get_current_frame ();
1819 struct gdbarch *gdbarch = get_frame_arch (frame);
1820 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1822 struct objc_super sstr;
1828 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1829 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1831 read_objc_super (gdbarch, super, &sstr);
1832 if (sstr.class == 0)
1835 res = find_implementation_from_class (gdbarch, sstr.class, sel);
1844 _initialize_objc_lang (void)
1846 objc_objfile_data = register_objfile_data ();