1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2013 Free Software Foundation, Inc.
5 Contributed by Apple Computer, Inc.
6 Written by Michael Snyder.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
27 #include "parser-defs.h"
30 #include "objc-lang.h"
31 #include "exceptions.h"
32 #include "complaints.h"
36 #include "gdb_string.h" /* for strchr */
37 #include "target.h" /* for target_has_execution */
41 #include "gdb_regex.h"
46 #include "gdb_assert.h"
56 CORE_ADDR super_class;
78 static const struct objfile_data *objc_objfile_data;
80 /* Lookup a structure type named "struct NAME", visible in lexical
81 block BLOCK. If NOERR is nonzero, return zero if NAME is not
85 lookup_struct_typedef (char *name, const struct block *block, int noerr)
89 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
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 (struct gdbarch *gdbarch, char *classname)
112 struct type *char_type = builtin_type (gdbarch)->builtin_char;
113 struct value * function, *classval;
115 if (! target_has_execution)
117 /* Can't call into inferior to lookup class. */
121 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
122 function = find_function_in_inferior("objc_lookUpClass", NULL);
123 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
124 function = find_function_in_inferior("objc_lookup_class", NULL);
127 complaint (&symfile_complaints,
128 _("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,
157 _("no way to lookup Objective-C selectors"));
161 selstring = value_coerce_array (value_string (selname,
162 strlen (selname) + 1,
164 return value_as_long (call_function_by_hand (function, 1, &selstring));
168 value_nsstring (struct gdbarch *gdbarch, char *ptr, int len)
170 struct type *char_type = builtin_type (gdbarch)->builtin_char;
171 struct value *stringValue[3];
172 struct value *function, *nsstringValue;
176 if (!target_has_execution)
177 return 0; /* Can't call into inferior to create NSString. */
179 stringValue[2] = value_string(ptr, len, char_type);
180 stringValue[2] = value_coerce_array(stringValue[2]);
181 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
182 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
184 function = find_function_in_inferior("_NSNewStringFromCString", NULL);
185 nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
187 else if (lookup_minimal_symbol("istr", 0, 0))
189 function = find_function_in_inferior("istr", NULL);
190 nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
192 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
195 = find_function_in_inferior("+[NSString stringWithCString:]", NULL);
196 type = builtin_type (gdbarch)->builtin_long;
198 stringValue[0] = value_from_longest
199 (type, lookup_objc_class (gdbarch, "NSString"));
200 stringValue[1] = value_from_longest
201 (type, lookup_child_selector (gdbarch, "stringWithCString:"));
202 nsstringValue = call_function_by_hand(function, 3, &stringValue[0]);
205 error (_("NSString: internal error -- no way to create new NSString"));
207 sym = lookup_struct_typedef("NSString", 0, 1);
209 sym = lookup_struct_typedef("NXString", 0, 1);
211 type = builtin_type (gdbarch)->builtin_data_ptr;
213 type = lookup_pointer_type(SYMBOL_TYPE (sym));
215 deprecated_set_value_type (nsstringValue, type);
216 return nsstringValue;
219 /* Objective-C name demangling. */
222 objc_demangle (const char *mangled, int options)
224 char *demangled, *cp;
226 if (mangled[0] == '_' &&
227 (mangled[1] == 'i' || mangled[1] == 'c') &&
230 cp = demangled = xmalloc(strlen(mangled) + 2);
232 if (mangled[1] == 'i')
233 *cp++ = '-'; /* for instance method */
235 *cp++ = '+'; /* for class method */
237 *cp++ = '['; /* opening left brace */
238 strcpy(cp, mangled+3); /* Tack on the rest of the mangled name. */
240 while (*cp && *cp == '_')
241 cp++; /* Skip any initial underbars in class
244 cp = strchr(cp, '_');
245 if (!cp) /* Find first non-initial underbar. */
247 xfree(demangled); /* not mangled name */
250 if (cp[1] == '_') /* Easy case: no category name. */
252 *cp++ = ' '; /* Replace two '_' with one ' '. */
253 strcpy(cp, mangled + (cp - demangled) + 2);
257 *cp++ = '('; /* Less easy case: category name. */
258 cp = strchr(cp, '_');
261 xfree(demangled); /* not mangled name */
265 *cp++ = ' '; /* Overwriting 1st char of method name... */
266 strcpy(cp, mangled + (cp - demangled)); /* Get it back. */
269 while (*cp && *cp == '_')
270 cp++; /* Skip any initial underbars in
275 *cp = ':'; /* Replace remaining '_' with ':'. */
277 *cp++ = ']'; /* closing right brace */
278 *cp++ = 0; /* string terminator */
282 return NULL; /* Not an objc mangled name. */
285 /* Print the character C on STREAM as part of the contents of a
286 literal string whose delimiter is QUOTER. Note that that format
287 for printing characters and strings is language specific. */
290 objc_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
292 c &= 0xFF; /* Avoid sign bit follies. */
294 if (PRINT_LITERAL_FORM (c))
296 if (c == '\\' || c == quoter)
298 fputs_filtered ("\\", stream);
300 fprintf_filtered (stream, "%c", c);
307 fputs_filtered ("\\n", stream);
310 fputs_filtered ("\\b", stream);
313 fputs_filtered ("\\t", stream);
316 fputs_filtered ("\\f", stream);
319 fputs_filtered ("\\r", stream);
322 fputs_filtered ("\\e", stream);
325 fputs_filtered ("\\a", stream);
328 fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
335 objc_printchar (int c, struct type *type, struct ui_file *stream)
337 fputs_filtered ("'", stream);
338 objc_emit_char (c, type, stream, '\'');
339 fputs_filtered ("'", stream);
342 /* Print the character string STRING, printing at most LENGTH
343 characters. Printing stops early if the number hits print_max;
344 repeat counts are printed as appropriate. Print ellipses at the
345 end if we had to stop before printing LENGTH characters, or if
349 objc_printstr (struct ui_file *stream, struct type *type,
350 const gdb_byte *string, unsigned int length,
351 const char *encoding, int force_ellipses,
352 const struct value_print_options *options)
355 unsigned int things_printed = 0;
359 /* If the string was not truncated due to `set print elements', and
360 the last byte of it is a null, we don't print that, in
361 traditional C style. */
362 if ((!force_ellipses) && length > 0 && string[length-1] == '\0')
367 fputs_filtered ("\"\"", stream);
371 for (i = 0; i < length && things_printed < options->print_max; ++i)
373 /* Position of the character we are examining to see whether it
376 /* Number of repetitions we have detected so far. */
383 fputs_filtered (", ", stream);
389 while (rep1 < length && string[rep1] == string[i])
395 if (reps > options->repeat_count_threshold)
399 fputs_filtered ("\", ", stream);
402 objc_printchar (string[i], type, stream);
403 fprintf_filtered (stream, " <repeats %u times>", reps);
405 things_printed += options->repeat_count_threshold;
412 fputs_filtered ("\"", stream);
415 objc_emit_char (string[i], type, stream, '"');
420 /* Terminate the quotes if necessary. */
422 fputs_filtered ("\"", stream);
424 if (force_ellipses || i < length)
425 fputs_filtered ("...", stream);
428 /* Determine if we are currently in the Objective-C dispatch function.
429 If so, get the address of the method function that the dispatcher
430 would call and use that as the function to step into instead. Also
431 skip over the trampoline for the function (if any). This is better
432 for the user since they are only interested in stepping into the
433 method function anyway. */
435 objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
437 struct gdbarch *gdbarch = get_frame_arch (frame);
438 CORE_ADDR real_stop_pc;
439 CORE_ADDR method_stop_pc;
441 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
443 if (real_stop_pc != 0)
444 find_objc_msgcall (real_stop_pc, &method_stop_pc);
446 find_objc_msgcall (stop_pc, &method_stop_pc);
450 real_stop_pc = gdbarch_skip_trampoline_code
451 (gdbarch, frame, method_stop_pc);
452 if (real_stop_pc == 0)
453 real_stop_pc = method_stop_pc;
460 /* Table mapping opcodes into strings for printing operators
461 and precedences of the operators. */
463 static const struct op_print objc_op_print_tab[] =
465 {",", BINOP_COMMA, PREC_COMMA, 0},
466 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
467 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
468 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
469 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
470 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
471 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
472 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
473 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
474 {"<=", BINOP_LEQ, PREC_ORDER, 0},
475 {">=", BINOP_GEQ, PREC_ORDER, 0},
476 {">", BINOP_GTR, PREC_ORDER, 0},
477 {"<", BINOP_LESS, PREC_ORDER, 0},
478 {">>", BINOP_RSH, PREC_SHIFT, 0},
479 {"<<", BINOP_LSH, PREC_SHIFT, 0},
480 {"+", BINOP_ADD, PREC_ADD, 0},
481 {"-", BINOP_SUB, PREC_ADD, 0},
482 {"*", BINOP_MUL, PREC_MUL, 0},
483 {"/", BINOP_DIV, PREC_MUL, 0},
484 {"%", BINOP_REM, PREC_MUL, 0},
485 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
486 {"-", UNOP_NEG, PREC_PREFIX, 0},
487 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
488 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
489 {"*", UNOP_IND, PREC_PREFIX, 0},
490 {"&", UNOP_ADDR, PREC_PREFIX, 0},
491 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
492 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
493 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
494 {NULL, OP_NULL, PREC_NULL, 0}
497 const struct language_defn objc_language_defn = {
498 "objective-c", /* Language name */
504 &exp_descriptor_standard,
508 objc_printchar, /* Print a character constant */
509 objc_printstr, /* Function to print string constant */
511 c_print_type, /* Print a type using appropriate syntax */
512 c_print_typedef, /* Print a typedef using appropriate syntax */
513 c_val_print, /* Print a value using appropriate syntax */
514 c_value_print, /* Print a top-level value */
515 default_read_var_value, /* la_read_var_value */
516 objc_skip_trampoline, /* Language specific skip_trampoline */
517 "self", /* name_of_this */
518 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
519 basic_lookup_transparent_type,/* lookup_transparent_type */
520 objc_demangle, /* Language specific symbol demangler */
521 NULL, /* Language specific
522 class_name_from_physname */
523 objc_op_print_tab, /* Expression operators for printing */
524 1, /* C-style arrays */
525 0, /* String lower bound */
526 default_word_break_characters,
527 default_make_symbol_completion_list,
528 c_language_arch_info,
529 default_print_array_index,
530 default_pass_by_reference,
532 NULL, /* la_get_symbol_name_cmp */
533 iterate_over_symbols,
539 * Following functions help construct Objective-C message calls.
542 struct selname /* For parsing Objective-C. */
544 struct selname *next;
549 static int msglist_len;
550 static struct selname *selname_chain;
551 static char *msglist_sel;
556 struct selname *new =
557 (struct selname *) xmalloc (sizeof (struct selname));
559 new->next = selname_chain;
560 new->msglist_len = msglist_len;
561 new->msglist_sel = msglist_sel;
563 msglist_sel = (char *)xmalloc(1);
569 add_msglist(struct stoken *str, int addcolon)
574 if (str == 0) /* Unnamed arg, or... */
576 if (addcolon == 0) /* variable number of args. */
589 len = plen + strlen(msglist_sel) + 2;
590 s = (char *)xmalloc(len);
591 strcpy(s, msglist_sel);
608 int val = msglist_len;
609 struct selname *sel = selname_chain;
610 char *p = msglist_sel;
613 selname_chain = sel->next;
614 msglist_len = sel->msglist_len;
615 msglist_sel = sel->msglist_sel;
616 selid = lookup_child_selector (parse_gdbarch, p);
618 error (_("Can't find selector \"%s\""), p);
619 write_exp_elt_longcst (selid);
621 write_exp_elt_longcst (val); /* Number of args */
628 * Function: specialcmp (const char *a, const char *b)
630 * Special strcmp: treats ']' and ' ' as end-of-string.
631 * Used for qsorting lists of objc methods (either by class or selector).
635 specialcmp (const char *a, const char *b)
637 while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']')
643 if (*a && *a != ' ' && *a != ']')
644 return 1; /* a is longer therefore greater. */
645 if (*b && *b != ' ' && *b != ']')
646 return -1; /* a is shorter therefore lesser. */
647 return 0; /* a and b are identical. */
651 * Function: compare_selectors (const void *, const void *)
653 * Comparison function for use with qsort. Arguments are symbols or
654 * msymbols Compares selector part of objc method name alphabetically.
658 compare_selectors (const void *a, const void *b)
660 const char *aname, *bname;
662 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
663 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
664 if (aname == NULL || bname == NULL)
665 error (_("internal: compare_selectors(1)"));
667 aname = strchr(aname, ' ');
668 bname = strchr(bname, ' ');
669 if (aname == NULL || bname == NULL)
670 error (_("internal: compare_selectors(2)"));
672 return specialcmp (aname+1, bname+1);
676 * Function: selectors_info (regexp, from_tty)
678 * Implements the "Info selectors" command. Takes an optional regexp
679 * arg. Lists all objective c selectors that match the regexp. Works
680 * by grepping thru all symbols for objective c methods. Output list
681 * is sorted and uniqued.
685 selectors_info (char *regexp, int from_tty)
687 struct objfile *objfile;
688 struct minimal_symbol *msymbol;
696 struct symbol **sym_arr;
700 strcpy(myregexp, ".*]"); /* Null input, match all objc methods. */
703 if (*regexp == '+' || *regexp == '-')
704 { /* User wants only class methods or only instance methods. */
705 plusminus = *regexp++;
706 while (*regexp == ' ' || *regexp == '\t')
710 strcpy(myregexp, ".*]");
713 /* Allow a few extra bytes because of the strcat below. */
714 if (sizeof (myregexp) < strlen (regexp) + 4)
715 error (_("Regexp is too long: %s"), regexp);
716 strcpy(myregexp, regexp);
717 if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
718 myregexp[strlen(myregexp) - 1] = ']'; /* end of method name */
720 strcat(myregexp, ".*]");
726 val = re_comp (myregexp);
728 error (_("Invalid regexp (%s): %s"), val, regexp);
731 /* First time thru is JUST to get max length and count. */
732 ALL_MSYMBOLS (objfile, msymbol)
735 name = SYMBOL_NATURAL_NAME (msymbol);
737 && (name[0] == '-' || name[0] == '+')
738 && name[1] == '[') /* Got a method name. */
740 /* Filter for class/instance methods. */
741 if (plusminus && name[0] != plusminus)
743 /* Find selector part. */
744 name = (char *) strchr (name+2, ' ');
747 complaint (&symfile_complaints,
748 _("Bad method name '%s'"),
749 SYMBOL_NATURAL_NAME (msymbol));
752 if (regexp == NULL || re_exec(++name) != 0)
754 const char *mystart = name;
755 const char *myend = strchr (mystart, ']');
757 if (myend && (myend - mystart > maxlen))
758 maxlen = myend - mystart; /* Get longest selector. */
765 printf_filtered (_("Selectors matching \"%s\":\n\n"),
766 regexp ? regexp : "*");
768 sym_arr = alloca (matches * sizeof (struct symbol *));
770 ALL_MSYMBOLS (objfile, msymbol)
773 name = SYMBOL_NATURAL_NAME (msymbol);
775 (name[0] == '-' || name[0] == '+') &&
776 name[1] == '[') /* Got a method name. */
778 /* Filter for class/instance methods. */
779 if (plusminus && name[0] != plusminus)
781 /* Find selector part. */
782 name = (char *) strchr(name+2, ' ');
783 if (regexp == NULL || re_exec(++name) != 0)
784 sym_arr[matches++] = (struct symbol *) msymbol;
788 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
790 /* Prevent compare on first iteration. */
792 for (ix = 0; ix < matches; ix++) /* Now do the output. */
797 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
798 name = strchr (name, ' ') + 1;
799 if (p[0] && specialcmp(name, p) == 0)
800 continue; /* Seen this one already (not unique). */
802 /* Copy selector part. */
803 while (*name && *name != ']')
806 /* Print in columns. */
807 puts_filtered_tabular(asel, maxlen + 1, 0);
812 printf_filtered (_("No selectors matching \"%s\"\n"),
813 regexp ? regexp : "*");
817 * Function: compare_classes (const void *, const void *)
819 * Comparison function for use with qsort. Arguments are symbols or
820 * msymbols Compares class part of objc method name alphabetically.
824 compare_classes (const void *a, const void *b)
826 const char *aname, *bname;
828 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
829 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
830 if (aname == NULL || bname == NULL)
831 error (_("internal: compare_classes(1)"));
833 return specialcmp (aname+1, bname+1);
837 * Function: classes_info(regexp, from_tty)
839 * Implements the "info classes" command for objective c classes.
840 * Lists all objective c classes that match the optional regexp.
841 * Works by grepping thru the list of objective c methods. List will
842 * be sorted and uniqued (since one class may have many methods).
843 * BUGS: will not list a class that has no methods.
847 classes_info (char *regexp, int from_tty)
849 struct objfile *objfile;
850 struct minimal_symbol *msymbol;
858 struct symbol **sym_arr;
861 strcpy(myregexp, ".* "); /* Null input: match all objc classes. */
864 /* Allow a few extra bytes because of the strcat below. */
865 if (sizeof (myregexp) < strlen (regexp) + 4)
866 error (_("Regexp is too long: %s"), regexp);
867 strcpy(myregexp, regexp);
868 if (myregexp[strlen(myregexp) - 1] == '$')
869 /* In the method name, the end of the class name is marked by ' '. */
870 myregexp[strlen(myregexp) - 1] = ' ';
872 strcat(myregexp, ".* ");
877 val = re_comp (myregexp);
879 error (_("Invalid regexp (%s): %s"), val, regexp);
882 /* First time thru is JUST to get max length and count. */
883 ALL_MSYMBOLS (objfile, msymbol)
886 name = SYMBOL_NATURAL_NAME (msymbol);
888 (name[0] == '-' || name[0] == '+') &&
889 name[1] == '[') /* Got a method name. */
890 if (regexp == NULL || re_exec(name+2) != 0)
892 /* Compute length of classname part. */
893 const char *mystart = name + 2;
894 const char *myend = strchr (mystart, ' ');
896 if (myend && (myend - mystart > maxlen))
897 maxlen = myend - mystart;
903 printf_filtered (_("Classes matching \"%s\":\n\n"),
904 regexp ? regexp : "*");
905 sym_arr = alloca (matches * sizeof (struct symbol *));
907 ALL_MSYMBOLS (objfile, msymbol)
910 name = SYMBOL_NATURAL_NAME (msymbol);
912 (name[0] == '-' || name[0] == '+') &&
913 name[1] == '[') /* Got a method name. */
914 if (regexp == NULL || re_exec(name+2) != 0)
915 sym_arr[matches++] = (struct symbol *) msymbol;
918 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
920 /* Prevent compare on first iteration. */
922 for (ix = 0; ix < matches; ix++) /* Now do the output. */
927 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
929 if (p[0] && specialcmp(name, p) == 0)
930 continue; /* Seen this one already (not unique). */
932 /* Copy class part of method name. */
933 while (*name && *name != ' ')
936 /* Print in columns. */
937 puts_filtered_tabular(aclass, maxlen + 1, 0);
942 printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*");
946 parse_selector (char *method, char **selector)
952 char *nselector = NULL;
954 gdb_assert (selector != NULL);
958 while (isspace (*s1))
965 while (isspace (*s1))
973 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
975 else if (isspace (*s2))
977 else if ((*s2 == '\0') || (*s2 == '\''))
985 while (isspace (*s2))
991 while (isspace (*s2))
995 if (selector != NULL)
996 *selector = nselector;
1002 parse_method (char *method, char *type, char **class,
1003 char **category, char **selector)
1007 int found_quote = 0;
1010 char *nclass = NULL;
1011 char *ncategory = NULL;
1012 char *nselector = NULL;
1014 gdb_assert (type != NULL);
1015 gdb_assert (class != NULL);
1016 gdb_assert (category != NULL);
1017 gdb_assert (selector != NULL);
1021 while (isspace (*s1))
1028 while (isspace (*s1))
1031 if ((s1[0] == '+') || (s1[0] == '-'))
1034 while (isspace (*s1))
1042 while (isalnum (*s1) || (*s1 == '_'))
1046 while (isspace (*s2))
1052 while (isspace (*s2))
1055 while (isalnum (*s2) || (*s2 == '_'))
1060 /* Truncate the class name now that we're not using the open paren. */
1068 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1070 else if (isspace (*s2))
1072 else if (*s2 == ']')
1081 while (isspace (*s2))
1088 while (isspace (*s2))
1096 if (category != NULL)
1097 *category = ncategory;
1098 if (selector != NULL)
1099 *selector = nselector;
1105 find_methods (char type, const char *class, const char *category,
1106 const char *selector,
1107 VEC (const_char_ptr) **symbol_names)
1109 struct objfile *objfile = NULL;
1111 const char *symname = NULL;
1114 char *nclass = NULL;
1115 char *ncategory = NULL;
1116 char *nselector = NULL;
1118 static char *tmp = NULL;
1119 static unsigned int tmplen = 0;
1121 gdb_assert (symbol_names != NULL);
1123 ALL_OBJFILES (objfile)
1125 unsigned int *objc_csym;
1126 struct minimal_symbol *msymbol = NULL;
1128 /* The objfile_csym variable counts the number of ObjC methods
1129 that this objfile defines. We save that count as a private
1130 objfile data. If we have already determined that this objfile
1131 provides no ObjC methods, we can skip it entirely. */
1133 unsigned int objfile_csym = 0;
1135 objc_csym = objfile_data (objfile, objc_objfile_data);
1136 if (objc_csym != NULL && *objc_csym == 0)
1137 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1140 ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
1142 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1146 /* Check the symbol name first as this can be done entirely without
1147 sending any query to the target. */
1148 symname = SYMBOL_NATURAL_NAME (msymbol);
1149 if (symname == NULL)
1152 if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1153 /* Not a method name. */
1158 /* Now that thinks are a bit sane, clean up the symname. */
1159 while ((strlen (symname) + 1) >= tmplen)
1161 tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1162 tmp = xrealloc (tmp, tmplen);
1164 strcpy (tmp, symname);
1166 if (parse_method (tmp, &ntype, &nclass,
1167 &ncategory, &nselector) == NULL)
1170 if ((type != '\0') && (ntype != type))
1174 && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1177 if ((category != NULL) &&
1178 ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1181 if ((selector != NULL) &&
1182 ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1185 VEC_safe_push (const_char_ptr, *symbol_names, symname);
1188 if (objc_csym == NULL)
1190 objc_csym = obstack_alloc (&objfile->objfile_obstack,
1191 sizeof (*objc_csym));
1192 *objc_csym = objfile_csym;
1193 set_objfile_data (objfile, objc_objfile_data, objc_csym);
1196 /* Count of ObjC methods in this objfile should be constant. */
1197 gdb_assert (*objc_csym == objfile_csym);
1201 /* Uniquify a VEC of strings. */
1204 uniquify_strings (VEC (const_char_ptr) **strings)
1207 const char *elem, *last = NULL;
1210 qsort (VEC_address (const_char_ptr, *strings),
1211 VEC_length (const_char_ptr, *strings),
1212 sizeof (const_char_ptr),
1215 for (ix = 0; VEC_iterate (const_char_ptr, *strings, ix, elem); ++ix)
1217 if (last == NULL || strcmp (last, elem) != 0)
1220 VEC_replace (const_char_ptr, *strings, out, elem);
1225 VEC_truncate (const_char_ptr, *strings, out);
1229 * Function: find_imps (char *selector, struct symbol **sym_arr)
1231 * Input: a string representing a selector
1232 * a pointer to an array of symbol pointers
1233 * possibly a pointer to a symbol found by the caller.
1235 * Output: number of methods that implement that selector. Side
1236 * effects: The array of symbol pointers is filled with matching syms.
1238 * By analogy with function "find_methods" (symtab.c), builds a list
1239 * of symbols matching the ambiguous input, so that "decode_line_2"
1240 * (symtab.c) can list them and ask the user to choose one or more.
1241 * In this case the matches are objective c methods
1242 * ("implementations") matching an objective c selector.
1244 * Note that it is possible for a normal (c-style) function to have
1245 * the same name as an objective c selector. To prevent the selector
1246 * from eclipsing the function, we allow the caller (decode_line_1) to
1247 * search for such a function first, and if it finds one, pass it in
1248 * to us. We will then integrate it into the list. We also search
1249 * for one here, among the minsyms.
1251 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1252 * into two parts: debuggable (struct symbol) syms, and
1253 * non_debuggable (struct minimal_symbol) syms. The debuggable
1254 * ones will come first, before NUM_DEBUGGABLE (which will thus
1255 * be the index of the first non-debuggable one).
1259 find_imps (char *method, VEC (const_char_ptr) **symbol_names)
1263 char *category = NULL;
1264 char *selector = NULL;
1269 int selector_case = 0;
1271 gdb_assert (symbol_names != NULL);
1273 buf = (char *) alloca (strlen (method) + 1);
1274 strcpy (buf, method);
1275 tmp = parse_method (buf, &type, &class, &category, &selector);
1279 strcpy (buf, method);
1280 tmp = parse_selector (buf, &selector);
1288 find_methods (type, class, category, selector, symbol_names);
1290 /* If we hit the "selector" case, and we found some methods, then
1291 add the selector itself as a symbol, if it exists. */
1292 if (selector_case && !VEC_empty (const_char_ptr, *symbol_names))
1294 struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN, 0);
1297 VEC_safe_push (const_char_ptr, *symbol_names,
1298 SYMBOL_NATURAL_NAME (sym));
1301 struct minimal_symbol *msym = lookup_minimal_symbol (selector, 0, 0);
1304 VEC_safe_push (const_char_ptr, *symbol_names,
1305 SYMBOL_NATURAL_NAME (msym));
1309 uniquify_strings (symbol_names);
1311 return method + (tmp - buf);
1315 print_object_command (char *args, int from_tty)
1317 struct value *object, *function, *description;
1318 CORE_ADDR string_addr, object_addr;
1322 if (!args || !*args)
1324 "The 'print-object' command requires an argument (an Objective-C object)");
1327 struct expression *expr = parse_expression (args);
1328 struct cleanup *old_chain =
1329 make_cleanup (free_current_contents, &expr);
1332 object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1333 expr, &pc, EVAL_NORMAL);
1334 do_cleanups (old_chain);
1337 /* Validate the address for sanity. */
1338 object_addr = value_as_long (object);
1339 read_memory (object_addr, &c, 1);
1341 function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1342 if (function == NULL)
1343 error (_("Unable to locate _NSPrintForDebugger in child process"));
1345 description = call_function_by_hand (function, 1, &object);
1347 string_addr = value_as_long (description);
1348 if (string_addr == 0)
1349 error (_("object returns null description"));
1351 read_memory (string_addr + i++, &c, 1);
1354 { /* Read and print characters up to EOS. */
1356 printf_filtered ("%c", c);
1357 read_memory (string_addr + i++, &c, 1);
1360 printf_filtered(_("<object returns empty description>"));
1361 printf_filtered ("\n");
1364 /* The data structure 'methcalls' is used to detect method calls (thru
1365 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1366 * and ultimately find the method being called.
1369 struct objc_methcall {
1371 /* Return instance method to be called. */
1372 int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1373 /* Start of pc range corresponding to method invocation. */
1375 /* End of pc range corresponding to method invocation. */
1379 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1380 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1381 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1382 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1384 static struct objc_methcall methcalls[] = {
1385 { "_objc_msgSend", resolve_msgsend, 0, 0},
1386 { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1387 { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1388 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1389 { "_objc_getClass", NULL, 0, 0},
1390 { "_objc_getMetaClass", NULL, 0, 0}
1393 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1395 /* The following function, "find_objc_msgsend", fills in the data
1396 * structure "objc_msgs" by finding the addresses of each of the
1397 * (currently four) functions that it holds (of which objc_msgSend is
1398 * the first). This must be called each time symbols are loaded, in
1399 * case the functions have moved for some reason.
1403 find_objc_msgsend (void)
1407 for (i = 0; i < nmethcalls; i++)
1409 struct minimal_symbol *func;
1411 /* Try both with and without underscore. */
1412 func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1413 if ((func == NULL) && (methcalls[i].name[0] == '_'))
1415 func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1419 methcalls[i].begin = 0;
1420 methcalls[i].end = 0;
1424 methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1426 methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1427 } while (methcalls[i].begin == methcalls[i].end);
1431 /* find_objc_msgcall (replaces pc_off_limits)
1433 * ALL that this function now does is to determine whether the input
1434 * address ("pc") is the address of one of the Objective-C message
1435 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1436 * if so, it returns the address of the method that will be called.
1438 * The old function "pc_off_limits" used to do a lot of other things
1439 * in addition, such as detecting shared library jump stubs and
1440 * returning the address of the shlib function that would be called.
1441 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1442 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1443 * dependent modules.
1446 struct objc_submethod_helper_data {
1447 int (*f) (CORE_ADDR, CORE_ADDR *);
1453 find_objc_msgcall_submethod_helper (void * arg)
1455 struct objc_submethod_helper_data *s =
1456 (struct objc_submethod_helper_data *) arg;
1458 if (s->f (s->pc, s->new_pc) == 0)
1465 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1469 struct objc_submethod_helper_data s;
1475 if (catch_errors (find_objc_msgcall_submethod_helper,
1477 "Unable to determine target of "
1478 "Objective-C method call (ignoring):\n",
1479 RETURN_MASK_ALL) == 0)
1486 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1490 find_objc_msgsend ();
1496 for (i = 0; i < nmethcalls; i++)
1497 if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1499 if (methcalls[i].stop_at != NULL)
1500 return find_objc_msgcall_submethod (methcalls[i].stop_at,
1509 /* -Wmissing-prototypes */
1510 extern initialize_file_ftype _initialize_objc_language;
1513 _initialize_objc_language (void)
1515 add_language (&objc_language_defn);
1516 add_info ("selectors", selectors_info, /* INFO SELECTORS command. */
1517 _("All Objective-C selectors, or those matching REGEXP."));
1518 add_info ("classes", classes_info, /* INFO CLASSES command. */
1519 _("All Objective-C classes, or those matching REGEXP."));
1520 add_com ("print-object", class_vars, print_object_command,
1521 _("Ask an Objective-C object to print itself."));
1522 add_com_alias ("po", "print-object", class_vars, 1);
1526 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1527 struct objc_method *method)
1529 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1531 method->name = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1532 method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1533 method->imp = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1536 static unsigned long
1537 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1539 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1541 return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1545 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1546 unsigned long num, struct objc_method *method)
1548 gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1549 read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1553 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1554 struct objc_object *object)
1556 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1558 object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1562 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1563 struct objc_super *super)
1565 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1567 super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1568 super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1572 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1573 struct objc_class *class)
1575 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1577 class->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1578 class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1579 class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1580 class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1581 class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
1582 class->instance_size = read_memory_unsigned_integer (addr + 18, 4,
1584 class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1585 class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1586 class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1587 class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1591 find_implementation_from_class (struct gdbarch *gdbarch,
1592 CORE_ADDR class, CORE_ADDR sel)
1594 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1595 CORE_ADDR subclass = class;
1597 while (subclass != 0)
1600 struct objc_class class_str;
1601 unsigned mlistnum = 0;
1603 read_objc_class (gdbarch, subclass, &class_str);
1608 unsigned long nmethods;
1611 mlist = read_memory_unsigned_integer (class_str.methods +
1617 nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1619 for (i = 0; i < nmethods; i++)
1621 struct objc_method meth_str;
1623 read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
1626 "checking method 0x%lx against selector 0x%lx\n",
1627 meth_str.name, sel);
1630 if (meth_str.name == sel)
1631 /* FIXME: hppa arch was doing a pointer dereference
1632 here. There needs to be a better way to do that. */
1633 return meth_str.imp;
1637 subclass = class_str.super_class;
1644 find_implementation (struct gdbarch *gdbarch,
1645 CORE_ADDR object, CORE_ADDR sel)
1647 struct objc_object ostr;
1651 read_objc_object (gdbarch, object, &ostr);
1655 return find_implementation_from_class (gdbarch, ostr.isa, sel);
1659 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1661 struct frame_info *frame = get_current_frame ();
1662 struct gdbarch *gdbarch = get_frame_arch (frame);
1663 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1669 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1670 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1672 res = find_implementation (gdbarch, object, sel);
1681 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1683 struct frame_info *frame = get_current_frame ();
1684 struct gdbarch *gdbarch = get_frame_arch (frame);
1685 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1691 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1692 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1694 res = find_implementation (gdbarch, object, sel);
1703 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1705 struct frame_info *frame = get_current_frame ();
1706 struct gdbarch *gdbarch = get_frame_arch (frame);
1707 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1709 struct objc_super sstr;
1715 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1716 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1718 read_objc_super (gdbarch, super, &sstr);
1719 if (sstr.class == 0)
1722 res = find_implementation_from_class (gdbarch, sstr.class, sel);
1731 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1733 struct frame_info *frame = get_current_frame ();
1734 struct gdbarch *gdbarch = get_frame_arch (frame);
1735 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1737 struct objc_super sstr;
1743 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1744 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1746 read_objc_super (gdbarch, super, &sstr);
1747 if (sstr.class == 0)
1750 res = find_implementation_from_class (gdbarch, sstr.class, sel);
1758 /* Provide a prototype to silence -Wmissing-prototypes. */
1759 extern initialize_file_ftype _initialize_objc_lang;
1762 _initialize_objc_lang (void)
1764 objc_objfile_data = register_objfile_data ();