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 /* Determine if we are currently in the Objective-C dispatch function.
286 If so, get the address of the method function that the dispatcher
287 would call and use that as the function to step into instead. Also
288 skip over the trampoline for the function (if any). This is better
289 for the user since they are only interested in stepping into the
290 method function anyway. */
292 objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
294 struct gdbarch *gdbarch = get_frame_arch (frame);
295 CORE_ADDR real_stop_pc;
296 CORE_ADDR method_stop_pc;
298 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
300 if (real_stop_pc != 0)
301 find_objc_msgcall (real_stop_pc, &method_stop_pc);
303 find_objc_msgcall (stop_pc, &method_stop_pc);
307 real_stop_pc = gdbarch_skip_trampoline_code
308 (gdbarch, frame, method_stop_pc);
309 if (real_stop_pc == 0)
310 real_stop_pc = method_stop_pc;
317 /* Table mapping opcodes into strings for printing operators
318 and precedences of the operators. */
320 static const struct op_print objc_op_print_tab[] =
322 {",", BINOP_COMMA, PREC_COMMA, 0},
323 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
324 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
325 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
326 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
327 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
328 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
329 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
330 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
331 {"<=", BINOP_LEQ, PREC_ORDER, 0},
332 {">=", BINOP_GEQ, PREC_ORDER, 0},
333 {">", BINOP_GTR, PREC_ORDER, 0},
334 {"<", BINOP_LESS, PREC_ORDER, 0},
335 {">>", BINOP_RSH, PREC_SHIFT, 0},
336 {"<<", BINOP_LSH, PREC_SHIFT, 0},
337 {"+", BINOP_ADD, PREC_ADD, 0},
338 {"-", BINOP_SUB, PREC_ADD, 0},
339 {"*", BINOP_MUL, PREC_MUL, 0},
340 {"/", BINOP_DIV, PREC_MUL, 0},
341 {"%", BINOP_REM, PREC_MUL, 0},
342 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
343 {"-", UNOP_NEG, PREC_PREFIX, 0},
344 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
345 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
346 {"*", UNOP_IND, PREC_PREFIX, 0},
347 {"&", UNOP_ADDR, PREC_PREFIX, 0},
348 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
349 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
350 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
351 {NULL, OP_NULL, PREC_NULL, 0}
354 const struct language_defn objc_language_defn = {
355 "objective-c", /* Language name */
361 &exp_descriptor_standard,
365 c_printchar, /* Print a character constant */
366 c_printstr, /* Function to print string constant */
368 c_print_type, /* Print a type using appropriate syntax */
369 c_print_typedef, /* Print a typedef using appropriate syntax */
370 c_val_print, /* Print a value using appropriate syntax */
371 c_value_print, /* Print a top-level value */
372 default_read_var_value, /* la_read_var_value */
373 objc_skip_trampoline, /* Language specific skip_trampoline */
374 "self", /* name_of_this */
375 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
376 basic_lookup_transparent_type,/* lookup_transparent_type */
377 objc_demangle, /* Language specific symbol demangler */
378 NULL, /* Language specific
379 class_name_from_physname */
380 objc_op_print_tab, /* Expression operators for printing */
381 1, /* C-style arrays */
382 0, /* String lower bound */
383 default_word_break_characters,
384 default_make_symbol_completion_list,
385 c_language_arch_info,
386 default_print_array_index,
387 default_pass_by_reference,
389 NULL, /* la_get_symbol_name_cmp */
390 iterate_over_symbols,
396 * Following functions help construct Objective-C message calls.
399 struct selname /* For parsing Objective-C. */
401 struct selname *next;
406 static int msglist_len;
407 static struct selname *selname_chain;
408 static char *msglist_sel;
413 struct selname *new =
414 (struct selname *) xmalloc (sizeof (struct selname));
416 new->next = selname_chain;
417 new->msglist_len = msglist_len;
418 new->msglist_sel = msglist_sel;
420 msglist_sel = (char *)xmalloc(1);
426 add_msglist(struct stoken *str, int addcolon)
431 if (str == 0) /* Unnamed arg, or... */
433 if (addcolon == 0) /* variable number of args. */
446 len = plen + strlen(msglist_sel) + 2;
447 s = (char *)xmalloc(len);
448 strcpy(s, msglist_sel);
465 int val = msglist_len;
466 struct selname *sel = selname_chain;
467 char *p = msglist_sel;
470 selname_chain = sel->next;
471 msglist_len = sel->msglist_len;
472 msglist_sel = sel->msglist_sel;
473 selid = lookup_child_selector (parse_gdbarch, p);
475 error (_("Can't find selector \"%s\""), p);
476 write_exp_elt_longcst (selid);
478 write_exp_elt_longcst (val); /* Number of args */
485 * Function: specialcmp (const char *a, const char *b)
487 * Special strcmp: treats ']' and ' ' as end-of-string.
488 * Used for qsorting lists of objc methods (either by class or selector).
492 specialcmp (const char *a, const char *b)
494 while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']')
500 if (*a && *a != ' ' && *a != ']')
501 return 1; /* a is longer therefore greater. */
502 if (*b && *b != ' ' && *b != ']')
503 return -1; /* a is shorter therefore lesser. */
504 return 0; /* a and b are identical. */
508 * Function: compare_selectors (const void *, const void *)
510 * Comparison function for use with qsort. Arguments are symbols or
511 * msymbols Compares selector part of objc method name alphabetically.
515 compare_selectors (const void *a, const void *b)
517 const char *aname, *bname;
519 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
520 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
521 if (aname == NULL || bname == NULL)
522 error (_("internal: compare_selectors(1)"));
524 aname = strchr(aname, ' ');
525 bname = strchr(bname, ' ');
526 if (aname == NULL || bname == NULL)
527 error (_("internal: compare_selectors(2)"));
529 return specialcmp (aname+1, bname+1);
533 * Function: selectors_info (regexp, from_tty)
535 * Implements the "Info selectors" command. Takes an optional regexp
536 * arg. Lists all objective c selectors that match the regexp. Works
537 * by grepping thru all symbols for objective c methods. Output list
538 * is sorted and uniqued.
542 selectors_info (char *regexp, int from_tty)
544 struct objfile *objfile;
545 struct minimal_symbol *msymbol;
553 struct symbol **sym_arr;
557 strcpy(myregexp, ".*]"); /* Null input, match all objc methods. */
560 if (*regexp == '+' || *regexp == '-')
561 { /* User wants only class methods or only instance methods. */
562 plusminus = *regexp++;
563 while (*regexp == ' ' || *regexp == '\t')
567 strcpy(myregexp, ".*]");
570 /* Allow a few extra bytes because of the strcat below. */
571 if (sizeof (myregexp) < strlen (regexp) + 4)
572 error (_("Regexp is too long: %s"), regexp);
573 strcpy(myregexp, regexp);
574 if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
575 myregexp[strlen(myregexp) - 1] = ']'; /* end of method name */
577 strcat(myregexp, ".*]");
583 val = re_comp (myregexp);
585 error (_("Invalid regexp (%s): %s"), val, regexp);
588 /* First time thru is JUST to get max length and count. */
589 ALL_MSYMBOLS (objfile, msymbol)
592 name = SYMBOL_NATURAL_NAME (msymbol);
594 && (name[0] == '-' || name[0] == '+')
595 && name[1] == '[') /* Got a method name. */
597 /* Filter for class/instance methods. */
598 if (plusminus && name[0] != plusminus)
600 /* Find selector part. */
601 name = (char *) strchr (name+2, ' ');
604 complaint (&symfile_complaints,
605 _("Bad method name '%s'"),
606 SYMBOL_NATURAL_NAME (msymbol));
609 if (regexp == NULL || re_exec(++name) != 0)
611 const char *mystart = name;
612 const char *myend = strchr (mystart, ']');
614 if (myend && (myend - mystart > maxlen))
615 maxlen = myend - mystart; /* Get longest selector. */
622 printf_filtered (_("Selectors matching \"%s\":\n\n"),
623 regexp ? regexp : "*");
625 sym_arr = alloca (matches * sizeof (struct symbol *));
627 ALL_MSYMBOLS (objfile, msymbol)
630 name = SYMBOL_NATURAL_NAME (msymbol);
632 (name[0] == '-' || name[0] == '+') &&
633 name[1] == '[') /* Got a method name. */
635 /* Filter for class/instance methods. */
636 if (plusminus && name[0] != plusminus)
638 /* Find selector part. */
639 name = (char *) strchr(name+2, ' ');
640 if (regexp == NULL || re_exec(++name) != 0)
641 sym_arr[matches++] = (struct symbol *) msymbol;
645 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
647 /* Prevent compare on first iteration. */
649 for (ix = 0; ix < matches; ix++) /* Now do the output. */
654 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
655 name = strchr (name, ' ') + 1;
656 if (p[0] && specialcmp(name, p) == 0)
657 continue; /* Seen this one already (not unique). */
659 /* Copy selector part. */
660 while (*name && *name != ']')
663 /* Print in columns. */
664 puts_filtered_tabular(asel, maxlen + 1, 0);
669 printf_filtered (_("No selectors matching \"%s\"\n"),
670 regexp ? regexp : "*");
674 * Function: compare_classes (const void *, const void *)
676 * Comparison function for use with qsort. Arguments are symbols or
677 * msymbols Compares class part of objc method name alphabetically.
681 compare_classes (const void *a, const void *b)
683 const char *aname, *bname;
685 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
686 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
687 if (aname == NULL || bname == NULL)
688 error (_("internal: compare_classes(1)"));
690 return specialcmp (aname+1, bname+1);
694 * Function: classes_info(regexp, from_tty)
696 * Implements the "info classes" command for objective c classes.
697 * Lists all objective c classes that match the optional regexp.
698 * Works by grepping thru the list of objective c methods. List will
699 * be sorted and uniqued (since one class may have many methods).
700 * BUGS: will not list a class that has no methods.
704 classes_info (char *regexp, int from_tty)
706 struct objfile *objfile;
707 struct minimal_symbol *msymbol;
715 struct symbol **sym_arr;
718 strcpy(myregexp, ".* "); /* Null input: match all objc classes. */
721 /* Allow a few extra bytes because of the strcat below. */
722 if (sizeof (myregexp) < strlen (regexp) + 4)
723 error (_("Regexp is too long: %s"), regexp);
724 strcpy(myregexp, regexp);
725 if (myregexp[strlen(myregexp) - 1] == '$')
726 /* In the method name, the end of the class name is marked by ' '. */
727 myregexp[strlen(myregexp) - 1] = ' ';
729 strcat(myregexp, ".* ");
734 val = re_comp (myregexp);
736 error (_("Invalid regexp (%s): %s"), val, regexp);
739 /* First time thru is JUST to get max length and count. */
740 ALL_MSYMBOLS (objfile, msymbol)
743 name = SYMBOL_NATURAL_NAME (msymbol);
745 (name[0] == '-' || name[0] == '+') &&
746 name[1] == '[') /* Got a method name. */
747 if (regexp == NULL || re_exec(name+2) != 0)
749 /* Compute length of classname part. */
750 const char *mystart = name + 2;
751 const char *myend = strchr (mystart, ' ');
753 if (myend && (myend - mystart > maxlen))
754 maxlen = myend - mystart;
760 printf_filtered (_("Classes matching \"%s\":\n\n"),
761 regexp ? regexp : "*");
762 sym_arr = alloca (matches * sizeof (struct symbol *));
764 ALL_MSYMBOLS (objfile, msymbol)
767 name = SYMBOL_NATURAL_NAME (msymbol);
769 (name[0] == '-' || name[0] == '+') &&
770 name[1] == '[') /* Got a method name. */
771 if (regexp == NULL || re_exec(name+2) != 0)
772 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]);
786 if (p[0] && specialcmp(name, p) == 0)
787 continue; /* Seen this one already (not unique). */
789 /* Copy class part of method name. */
790 while (*name && *name != ' ')
793 /* Print in columns. */
794 puts_filtered_tabular(aclass, maxlen + 1, 0);
799 printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*");
803 parse_selector (char *method, char **selector)
809 char *nselector = NULL;
811 gdb_assert (selector != NULL);
815 while (isspace (*s1))
822 while (isspace (*s1))
830 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
832 else if (isspace (*s2))
834 else if ((*s2 == '\0') || (*s2 == '\''))
842 while (isspace (*s2))
848 while (isspace (*s2))
852 if (selector != NULL)
853 *selector = nselector;
859 parse_method (char *method, char *type, char **class,
860 char **category, char **selector)
868 char *ncategory = NULL;
869 char *nselector = NULL;
871 gdb_assert (type != NULL);
872 gdb_assert (class != NULL);
873 gdb_assert (category != NULL);
874 gdb_assert (selector != NULL);
878 while (isspace (*s1))
885 while (isspace (*s1))
888 if ((s1[0] == '+') || (s1[0] == '-'))
891 while (isspace (*s1))
899 while (isalnum (*s1) || (*s1 == '_'))
903 while (isspace (*s2))
909 while (isspace (*s2))
912 while (isalnum (*s2) || (*s2 == '_'))
917 /* Truncate the class name now that we're not using the open paren. */
925 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
927 else if (isspace (*s2))
938 while (isspace (*s2))
945 while (isspace (*s2))
953 if (category != NULL)
954 *category = ncategory;
955 if (selector != NULL)
956 *selector = nselector;
962 find_methods (char type, const char *class, const char *category,
963 const char *selector,
964 VEC (const_char_ptr) **symbol_names)
966 struct objfile *objfile = NULL;
968 const char *symname = NULL;
972 char *ncategory = NULL;
973 char *nselector = NULL;
975 static char *tmp = NULL;
976 static unsigned int tmplen = 0;
978 gdb_assert (symbol_names != NULL);
980 ALL_OBJFILES (objfile)
982 unsigned int *objc_csym;
983 struct minimal_symbol *msymbol = NULL;
985 /* The objfile_csym variable counts the number of ObjC methods
986 that this objfile defines. We save that count as a private
987 objfile data. If we have already determined that this objfile
988 provides no ObjC methods, we can skip it entirely. */
990 unsigned int objfile_csym = 0;
992 objc_csym = objfile_data (objfile, objc_objfile_data);
993 if (objc_csym != NULL && *objc_csym == 0)
994 /* There are no ObjC symbols in this objfile. Skip it entirely. */
997 ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
999 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1003 /* Check the symbol name first as this can be done entirely without
1004 sending any query to the target. */
1005 symname = SYMBOL_NATURAL_NAME (msymbol);
1006 if (symname == NULL)
1009 if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1010 /* Not a method name. */
1015 /* Now that thinks are a bit sane, clean up the symname. */
1016 while ((strlen (symname) + 1) >= tmplen)
1018 tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1019 tmp = xrealloc (tmp, tmplen);
1021 strcpy (tmp, symname);
1023 if (parse_method (tmp, &ntype, &nclass,
1024 &ncategory, &nselector) == NULL)
1027 if ((type != '\0') && (ntype != type))
1031 && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1034 if ((category != NULL) &&
1035 ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1038 if ((selector != NULL) &&
1039 ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1042 VEC_safe_push (const_char_ptr, *symbol_names, symname);
1045 if (objc_csym == NULL)
1047 objc_csym = obstack_alloc (&objfile->objfile_obstack,
1048 sizeof (*objc_csym));
1049 *objc_csym = objfile_csym;
1050 set_objfile_data (objfile, objc_objfile_data, objc_csym);
1053 /* Count of ObjC methods in this objfile should be constant. */
1054 gdb_assert (*objc_csym == objfile_csym);
1058 /* Uniquify a VEC of strings. */
1061 uniquify_strings (VEC (const_char_ptr) **strings)
1064 const char *elem, *last = NULL;
1067 qsort (VEC_address (const_char_ptr, *strings),
1068 VEC_length (const_char_ptr, *strings),
1069 sizeof (const_char_ptr),
1072 for (ix = 0; VEC_iterate (const_char_ptr, *strings, ix, elem); ++ix)
1074 if (last == NULL || strcmp (last, elem) != 0)
1077 VEC_replace (const_char_ptr, *strings, out, elem);
1082 VEC_truncate (const_char_ptr, *strings, out);
1086 * Function: find_imps (char *selector, struct symbol **sym_arr)
1088 * Input: a string representing a selector
1089 * a pointer to an array of symbol pointers
1090 * possibly a pointer to a symbol found by the caller.
1092 * Output: number of methods that implement that selector. Side
1093 * effects: The array of symbol pointers is filled with matching syms.
1095 * By analogy with function "find_methods" (symtab.c), builds a list
1096 * of symbols matching the ambiguous input, so that "decode_line_2"
1097 * (symtab.c) can list them and ask the user to choose one or more.
1098 * In this case the matches are objective c methods
1099 * ("implementations") matching an objective c selector.
1101 * Note that it is possible for a normal (c-style) function to have
1102 * the same name as an objective c selector. To prevent the selector
1103 * from eclipsing the function, we allow the caller (decode_line_1) to
1104 * search for such a function first, and if it finds one, pass it in
1105 * to us. We will then integrate it into the list. We also search
1106 * for one here, among the minsyms.
1108 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1109 * into two parts: debuggable (struct symbol) syms, and
1110 * non_debuggable (struct minimal_symbol) syms. The debuggable
1111 * ones will come first, before NUM_DEBUGGABLE (which will thus
1112 * be the index of the first non-debuggable one).
1116 find_imps (char *method, VEC (const_char_ptr) **symbol_names)
1120 char *category = NULL;
1121 char *selector = NULL;
1126 int selector_case = 0;
1128 gdb_assert (symbol_names != NULL);
1130 buf = (char *) alloca (strlen (method) + 1);
1131 strcpy (buf, method);
1132 tmp = parse_method (buf, &type, &class, &category, &selector);
1136 strcpy (buf, method);
1137 tmp = parse_selector (buf, &selector);
1145 find_methods (type, class, category, selector, symbol_names);
1147 /* If we hit the "selector" case, and we found some methods, then
1148 add the selector itself as a symbol, if it exists. */
1149 if (selector_case && !VEC_empty (const_char_ptr, *symbol_names))
1151 struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN, 0);
1154 VEC_safe_push (const_char_ptr, *symbol_names,
1155 SYMBOL_NATURAL_NAME (sym));
1158 struct minimal_symbol *msym = lookup_minimal_symbol (selector, 0, 0);
1161 VEC_safe_push (const_char_ptr, *symbol_names,
1162 SYMBOL_NATURAL_NAME (msym));
1166 uniquify_strings (symbol_names);
1168 return method + (tmp - buf);
1172 print_object_command (char *args, int from_tty)
1174 struct value *object, *function, *description;
1175 CORE_ADDR string_addr, object_addr;
1179 if (!args || !*args)
1181 "The 'print-object' command requires an argument (an Objective-C object)");
1184 struct expression *expr = parse_expression (args);
1185 struct cleanup *old_chain =
1186 make_cleanup (free_current_contents, &expr);
1189 object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1190 expr, &pc, EVAL_NORMAL);
1191 do_cleanups (old_chain);
1194 /* Validate the address for sanity. */
1195 object_addr = value_as_long (object);
1196 read_memory (object_addr, &c, 1);
1198 function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1199 if (function == NULL)
1200 error (_("Unable to locate _NSPrintForDebugger in child process"));
1202 description = call_function_by_hand (function, 1, &object);
1204 string_addr = value_as_long (description);
1205 if (string_addr == 0)
1206 error (_("object returns null description"));
1208 read_memory (string_addr + i++, &c, 1);
1211 { /* Read and print characters up to EOS. */
1213 printf_filtered ("%c", c);
1214 read_memory (string_addr + i++, &c, 1);
1217 printf_filtered(_("<object returns empty description>"));
1218 printf_filtered ("\n");
1221 /* The data structure 'methcalls' is used to detect method calls (thru
1222 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1223 * and ultimately find the method being called.
1226 struct objc_methcall {
1228 /* Return instance method to be called. */
1229 int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1230 /* Start of pc range corresponding to method invocation. */
1232 /* End of pc range corresponding to method invocation. */
1236 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1237 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1238 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1239 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1241 static struct objc_methcall methcalls[] = {
1242 { "_objc_msgSend", resolve_msgsend, 0, 0},
1243 { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1244 { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1245 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1246 { "_objc_getClass", NULL, 0, 0},
1247 { "_objc_getMetaClass", NULL, 0, 0}
1250 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1252 /* The following function, "find_objc_msgsend", fills in the data
1253 * structure "objc_msgs" by finding the addresses of each of the
1254 * (currently four) functions that it holds (of which objc_msgSend is
1255 * the first). This must be called each time symbols are loaded, in
1256 * case the functions have moved for some reason.
1260 find_objc_msgsend (void)
1264 for (i = 0; i < nmethcalls; i++)
1266 struct minimal_symbol *func;
1268 /* Try both with and without underscore. */
1269 func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1270 if ((func == NULL) && (methcalls[i].name[0] == '_'))
1272 func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1276 methcalls[i].begin = 0;
1277 methcalls[i].end = 0;
1281 methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1283 methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1284 } while (methcalls[i].begin == methcalls[i].end);
1288 /* find_objc_msgcall (replaces pc_off_limits)
1290 * ALL that this function now does is to determine whether the input
1291 * address ("pc") is the address of one of the Objective-C message
1292 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1293 * if so, it returns the address of the method that will be called.
1295 * The old function "pc_off_limits" used to do a lot of other things
1296 * in addition, such as detecting shared library jump stubs and
1297 * returning the address of the shlib function that would be called.
1298 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1299 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1300 * dependent modules.
1303 struct objc_submethod_helper_data {
1304 int (*f) (CORE_ADDR, CORE_ADDR *);
1310 find_objc_msgcall_submethod_helper (void * arg)
1312 struct objc_submethod_helper_data *s =
1313 (struct objc_submethod_helper_data *) arg;
1315 if (s->f (s->pc, s->new_pc) == 0)
1322 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1326 struct objc_submethod_helper_data s;
1332 if (catch_errors (find_objc_msgcall_submethod_helper,
1334 "Unable to determine target of "
1335 "Objective-C method call (ignoring):\n",
1336 RETURN_MASK_ALL) == 0)
1343 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1347 find_objc_msgsend ();
1353 for (i = 0; i < nmethcalls; i++)
1354 if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1356 if (methcalls[i].stop_at != NULL)
1357 return find_objc_msgcall_submethod (methcalls[i].stop_at,
1366 /* -Wmissing-prototypes */
1367 extern initialize_file_ftype _initialize_objc_language;
1370 _initialize_objc_language (void)
1372 add_language (&objc_language_defn);
1373 add_info ("selectors", selectors_info, /* INFO SELECTORS command. */
1374 _("All Objective-C selectors, or those matching REGEXP."));
1375 add_info ("classes", classes_info, /* INFO CLASSES command. */
1376 _("All Objective-C classes, or those matching REGEXP."));
1377 add_com ("print-object", class_vars, print_object_command,
1378 _("Ask an Objective-C object to print itself."));
1379 add_com_alias ("po", "print-object", class_vars, 1);
1383 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1384 struct objc_method *method)
1386 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1388 method->name = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1389 method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1390 method->imp = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1393 static unsigned long
1394 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1396 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1398 return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1402 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1403 unsigned long num, struct objc_method *method)
1405 gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1406 read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1410 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1411 struct objc_object *object)
1413 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1415 object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1419 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1420 struct objc_super *super)
1422 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1424 super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1425 super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1429 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1430 struct objc_class *class)
1432 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1434 class->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1435 class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1436 class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1437 class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1438 class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
1439 class->instance_size = read_memory_unsigned_integer (addr + 18, 4,
1441 class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1442 class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1443 class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1444 class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1448 find_implementation_from_class (struct gdbarch *gdbarch,
1449 CORE_ADDR class, CORE_ADDR sel)
1451 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1452 CORE_ADDR subclass = class;
1454 while (subclass != 0)
1457 struct objc_class class_str;
1458 unsigned mlistnum = 0;
1460 read_objc_class (gdbarch, subclass, &class_str);
1465 unsigned long nmethods;
1468 mlist = read_memory_unsigned_integer (class_str.methods +
1474 nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1476 for (i = 0; i < nmethods; i++)
1478 struct objc_method meth_str;
1480 read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
1483 "checking method 0x%lx against selector 0x%lx\n",
1484 meth_str.name, sel);
1487 if (meth_str.name == sel)
1488 /* FIXME: hppa arch was doing a pointer dereference
1489 here. There needs to be a better way to do that. */
1490 return meth_str.imp;
1494 subclass = class_str.super_class;
1501 find_implementation (struct gdbarch *gdbarch,
1502 CORE_ADDR object, CORE_ADDR sel)
1504 struct objc_object ostr;
1508 read_objc_object (gdbarch, object, &ostr);
1512 return find_implementation_from_class (gdbarch, ostr.isa, sel);
1516 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1518 struct frame_info *frame = get_current_frame ();
1519 struct gdbarch *gdbarch = get_frame_arch (frame);
1520 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1526 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1527 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1529 res = find_implementation (gdbarch, object, sel);
1538 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1540 struct frame_info *frame = get_current_frame ();
1541 struct gdbarch *gdbarch = get_frame_arch (frame);
1542 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1548 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1549 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1551 res = find_implementation (gdbarch, object, sel);
1560 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1562 struct frame_info *frame = get_current_frame ();
1563 struct gdbarch *gdbarch = get_frame_arch (frame);
1564 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1566 struct objc_super sstr;
1572 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1573 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1575 read_objc_super (gdbarch, super, &sstr);
1576 if (sstr.class == 0)
1579 res = find_implementation_from_class (gdbarch, sstr.class, sel);
1588 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1590 struct frame_info *frame = get_current_frame ();
1591 struct gdbarch *gdbarch = get_frame_arch (frame);
1592 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1594 struct objc_super sstr;
1600 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1601 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1603 read_objc_super (gdbarch, super, &sstr);
1604 if (sstr.class == 0)
1607 res = find_implementation_from_class (gdbarch, sstr.class, sel);
1615 /* Provide a prototype to silence -Wmissing-prototypes. */
1616 extern initialize_file_ftype _initialize_objc_lang;
1619 _initialize_objc_lang (void)
1621 objc_objfile_data = register_objfile_data ();