1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002-2017 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"
31 #include "objc-lang.h"
32 #include "complaints.h"
36 #include "target.h" /* for target_has_execution */
40 #include "gdb_regex.h"
45 #include "cli/cli-utils.h"
55 CORE_ADDR super_class;
77 static const struct objfile_data *objc_objfile_data;
79 /* Lookup a structure type named "struct NAME", visible in lexical
80 block BLOCK. If NOERR is nonzero, return zero if NAME is not
84 lookup_struct_typedef (const char *name, const struct block *block, int noerr)
88 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0).symbol;
95 error (_("No struct type named %s."), name);
97 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
102 error (_("This context has class, union or enum %s, not a struct."),
109 lookup_objc_class (struct gdbarch *gdbarch, const char *classname)
111 struct type *char_type = builtin_type (gdbarch)->builtin_char;
112 struct value * function, *classval;
114 if (! target_has_execution)
116 /* Can't call into inferior to lookup class. */
120 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0).minsym)
121 function = find_function_in_inferior("objc_lookUpClass", NULL);
122 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0).minsym)
123 function = find_function_in_inferior("objc_lookup_class", NULL);
126 complaint (&symfile_complaints,
127 _("no way to lookup Objective-C classes"));
131 classval = value_string (classname, strlen (classname) + 1, char_type);
132 classval = value_coerce_array (classval);
133 return (CORE_ADDR) value_as_long (call_function_by_hand (function,
138 lookup_child_selector (struct gdbarch *gdbarch, const char *selname)
140 struct type *char_type = builtin_type (gdbarch)->builtin_char;
141 struct value * function, *selstring;
143 if (! target_has_execution)
145 /* Can't call into inferior to lookup selector. */
149 if (lookup_minimal_symbol("sel_getUid", 0, 0).minsym)
150 function = find_function_in_inferior("sel_getUid", NULL);
151 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0).minsym)
152 function = find_function_in_inferior("sel_get_any_uid", NULL);
155 complaint (&symfile_complaints,
156 _("no way to lookup Objective-C selectors"));
160 selstring = value_coerce_array (value_string (selname,
161 strlen (selname) + 1,
163 return value_as_long (call_function_by_hand (function, 1, &selstring));
167 value_nsstring (struct gdbarch *gdbarch, char *ptr, int len)
169 struct type *char_type = builtin_type (gdbarch)->builtin_char;
170 struct value *stringValue[3];
171 struct value *function, *nsstringValue;
175 if (!target_has_execution)
176 return 0; /* Can't call into inferior to create NSString. */
178 stringValue[2] = value_string(ptr, len, char_type);
179 stringValue[2] = value_coerce_array(stringValue[2]);
180 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
181 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0).minsym)
183 function = find_function_in_inferior("_NSNewStringFromCString", NULL);
184 nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
186 else if (lookup_minimal_symbol("istr", 0, 0).minsym)
188 function = find_function_in_inferior("istr", NULL);
189 nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
191 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0).minsym)
194 = find_function_in_inferior("+[NSString stringWithCString:]", NULL);
195 type = builtin_type (gdbarch)->builtin_long;
197 stringValue[0] = value_from_longest
198 (type, lookup_objc_class (gdbarch, "NSString"));
199 stringValue[1] = value_from_longest
200 (type, lookup_child_selector (gdbarch, "stringWithCString:"));
201 nsstringValue = call_function_by_hand(function, 3, &stringValue[0]);
204 error (_("NSString: internal error -- no way to create new NSString"));
206 sym = lookup_struct_typedef("NSString", 0, 1);
208 sym = lookup_struct_typedef("NXString", 0, 1);
210 type = builtin_type (gdbarch)->builtin_data_ptr;
212 type = lookup_pointer_type(SYMBOL_TYPE (sym));
214 deprecated_set_value_type (nsstringValue, type);
215 return nsstringValue;
218 /* Objective-C name demangling. */
221 objc_demangle (const char *mangled, int options)
223 char *demangled, *cp;
225 if (mangled[0] == '_' &&
226 (mangled[1] == 'i' || mangled[1] == 'c') &&
229 cp = demangled = (char *) xmalloc (strlen (mangled) + 2);
231 if (mangled[1] == 'i')
232 *cp++ = '-'; /* for instance method */
234 *cp++ = '+'; /* for class method */
236 *cp++ = '['; /* opening left brace */
237 strcpy(cp, mangled+3); /* Tack on the rest of the mangled name. */
239 while (*cp && *cp == '_')
240 cp++; /* Skip any initial underbars in class
243 cp = strchr(cp, '_');
244 if (!cp) /* Find first non-initial underbar. */
246 xfree(demangled); /* not mangled name */
249 if (cp[1] == '_') /* Easy case: no category name. */
251 *cp++ = ' '; /* Replace two '_' with one ' '. */
252 strcpy(cp, mangled + (cp - demangled) + 2);
256 *cp++ = '('; /* Less easy case: category name. */
257 cp = strchr(cp, '_');
260 xfree(demangled); /* not mangled name */
264 *cp++ = ' '; /* Overwriting 1st char of method name... */
265 strcpy(cp, mangled + (cp - demangled)); /* Get it back. */
268 while (*cp && *cp == '_')
269 cp++; /* Skip any initial underbars in
274 *cp = ':'; /* Replace remaining '_' with ':'. */
276 *cp++ = ']'; /* closing right brace */
277 *cp++ = 0; /* string terminator */
281 return NULL; /* Not an objc mangled name. */
284 /* la_sniff_from_mangled_name for ObjC. */
287 objc_sniff_from_mangled_name (const char *mangled, char **demangled)
289 *demangled = objc_demangle (mangled, 0);
290 return *demangled != NULL;
293 /* Determine if we are currently in the Objective-C dispatch function.
294 If so, get the address of the method function that the dispatcher
295 would call and use that as the function to step into instead. Also
296 skip over the trampoline for the function (if any). This is better
297 for the user since they are only interested in stepping into the
298 method function anyway. */
300 objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
302 struct gdbarch *gdbarch = get_frame_arch (frame);
303 CORE_ADDR real_stop_pc;
304 CORE_ADDR method_stop_pc;
306 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
308 if (real_stop_pc != 0)
309 find_objc_msgcall (real_stop_pc, &method_stop_pc);
311 find_objc_msgcall (stop_pc, &method_stop_pc);
315 real_stop_pc = gdbarch_skip_trampoline_code
316 (gdbarch, frame, method_stop_pc);
317 if (real_stop_pc == 0)
318 real_stop_pc = method_stop_pc;
325 /* Table mapping opcodes into strings for printing operators
326 and precedences of the operators. */
328 static const struct op_print objc_op_print_tab[] =
330 {",", BINOP_COMMA, PREC_COMMA, 0},
331 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
332 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
333 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
334 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
335 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
336 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
337 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
338 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
339 {"<=", BINOP_LEQ, PREC_ORDER, 0},
340 {">=", BINOP_GEQ, PREC_ORDER, 0},
341 {">", BINOP_GTR, PREC_ORDER, 0},
342 {"<", BINOP_LESS, PREC_ORDER, 0},
343 {">>", BINOP_RSH, PREC_SHIFT, 0},
344 {"<<", BINOP_LSH, PREC_SHIFT, 0},
345 {"+", BINOP_ADD, PREC_ADD, 0},
346 {"-", BINOP_SUB, PREC_ADD, 0},
347 {"*", BINOP_MUL, PREC_MUL, 0},
348 {"/", BINOP_DIV, PREC_MUL, 0},
349 {"%", BINOP_REM, PREC_MUL, 0},
350 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
351 {"-", UNOP_NEG, PREC_PREFIX, 0},
352 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
353 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
354 {"*", UNOP_IND, PREC_PREFIX, 0},
355 {"&", UNOP_ADDR, PREC_PREFIX, 0},
356 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
357 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
358 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
359 {NULL, OP_NULL, PREC_NULL, 0}
362 static const char *objc_extensions[] =
367 const struct language_defn objc_language_defn = {
368 "objective-c", /* Language name */
376 &exp_descriptor_standard,
380 c_printchar, /* Print a character constant */
381 c_printstr, /* Function to print string constant */
383 c_print_type, /* Print a type using appropriate syntax */
384 c_print_typedef, /* Print a typedef using appropriate syntax */
385 c_val_print, /* Print a value using appropriate syntax */
386 c_value_print, /* Print a top-level value */
387 default_read_var_value, /* la_read_var_value */
388 objc_skip_trampoline, /* Language specific skip_trampoline */
389 "self", /* name_of_this */
390 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
391 basic_lookup_transparent_type,/* lookup_transparent_type */
392 objc_demangle, /* Language specific symbol demangler */
393 objc_sniff_from_mangled_name,
394 NULL, /* Language specific
395 class_name_from_physname */
396 objc_op_print_tab, /* Expression operators for printing */
397 1, /* C-style arrays */
398 0, /* String lower bound */
399 default_word_break_characters,
400 default_collect_symbol_completion_matches,
401 c_language_arch_info,
402 default_print_array_index,
403 default_pass_by_reference,
405 c_watch_location_expression,
406 NULL, /* la_get_symbol_name_cmp */
407 iterate_over_symbols,
416 * Following functions help construct Objective-C message calls.
419 struct selname /* For parsing Objective-C. */
421 struct selname *next;
426 static int msglist_len;
427 static struct selname *selname_chain;
428 static char *msglist_sel;
433 struct selname *newobj = XNEW (struct selname);
435 newobj->next = selname_chain;
436 newobj->msglist_len = msglist_len;
437 newobj->msglist_sel = msglist_sel;
439 msglist_sel = (char *)xmalloc(1);
441 selname_chain = newobj;
445 add_msglist(struct stoken *str, int addcolon)
451 if (str == 0) /* Unnamed arg, or... */
453 if (addcolon == 0) /* variable number of args. */
466 len = plen + strlen(msglist_sel) + 2;
467 s = (char *)xmalloc(len);
468 strcpy(s, msglist_sel);
483 end_msglist (struct parser_state *ps)
485 int val = msglist_len;
486 struct selname *sel = selname_chain;
487 char *p = msglist_sel;
490 selname_chain = sel->next;
491 msglist_len = sel->msglist_len;
492 msglist_sel = sel->msglist_sel;
493 selid = lookup_child_selector (parse_gdbarch (ps), p);
495 error (_("Can't find selector \"%s\""), p);
496 write_exp_elt_longcst (ps, selid);
498 write_exp_elt_longcst (ps, val); /* Number of args */
505 * Function: specialcmp (const char *a, const char *b)
507 * Special strcmp: treats ']' and ' ' as end-of-string.
508 * Used for qsorting lists of objc methods (either by class or selector).
512 specialcmp (const char *a, const char *b)
514 while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']')
520 if (*a && *a != ' ' && *a != ']')
521 return 1; /* a is longer therefore greater. */
522 if (*b && *b != ' ' && *b != ']')
523 return -1; /* a is shorter therefore lesser. */
524 return 0; /* a and b are identical. */
528 * Function: compare_selectors (const void *, const void *)
530 * Comparison function for use with qsort. Arguments are symbols or
531 * msymbols Compares selector part of objc method name alphabetically.
535 compare_selectors (const void *a, const void *b)
537 const char *aname, *bname;
539 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
540 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
541 if (aname == NULL || bname == NULL)
542 error (_("internal: compare_selectors(1)"));
544 aname = strchr(aname, ' ');
545 bname = strchr(bname, ' ');
546 if (aname == NULL || bname == NULL)
547 error (_("internal: compare_selectors(2)"));
549 return specialcmp (aname+1, bname+1);
553 * Function: selectors_info (regexp, from_tty)
555 * Implements the "Info selectors" command. Takes an optional regexp
556 * arg. Lists all objective c selectors that match the regexp. Works
557 * by grepping thru all symbols for objective c methods. Output list
558 * is sorted and uniqued.
562 selectors_info (char *regexp, int from_tty)
564 struct objfile *objfile;
565 struct minimal_symbol *msymbol;
573 struct symbol **sym_arr;
577 strcpy(myregexp, ".*]"); /* Null input, match all objc methods. */
580 if (*regexp == '+' || *regexp == '-')
581 { /* User wants only class methods or only instance methods. */
582 plusminus = *regexp++;
583 while (*regexp == ' ' || *regexp == '\t')
587 strcpy(myregexp, ".*]");
590 /* Allow a few extra bytes because of the strcat below. */
591 if (sizeof (myregexp) < strlen (regexp) + 4)
592 error (_("Regexp is too long: %s"), regexp);
593 strcpy(myregexp, regexp);
594 if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
595 myregexp[strlen(myregexp) - 1] = ']'; /* end of method name */
597 strcat(myregexp, ".*]");
603 val = re_comp (myregexp);
605 error (_("Invalid regexp (%s): %s"), val, regexp);
608 /* First time thru is JUST to get max length and count. */
609 ALL_MSYMBOLS (objfile, msymbol)
612 name = MSYMBOL_NATURAL_NAME (msymbol);
614 && (name[0] == '-' || name[0] == '+')
615 && name[1] == '[') /* Got a method name. */
617 /* Filter for class/instance methods. */
618 if (plusminus && name[0] != plusminus)
620 /* Find selector part. */
621 name = (char *) strchr (name+2, ' ');
624 complaint (&symfile_complaints,
625 _("Bad method name '%s'"),
626 MSYMBOL_NATURAL_NAME (msymbol));
629 if (regexp == NULL || re_exec(++name) != 0)
631 const char *mystart = name;
632 const char *myend = strchr (mystart, ']');
634 if (myend && (myend - mystart > maxlen))
635 maxlen = myend - mystart; /* Get longest selector. */
642 printf_filtered (_("Selectors matching \"%s\":\n\n"),
643 regexp ? regexp : "*");
645 sym_arr = XALLOCAVEC (struct symbol *, matches);
647 ALL_MSYMBOLS (objfile, msymbol)
650 name = MSYMBOL_NATURAL_NAME (msymbol);
652 (name[0] == '-' || name[0] == '+') &&
653 name[1] == '[') /* Got a method name. */
655 /* Filter for class/instance methods. */
656 if (plusminus && name[0] != plusminus)
658 /* Find selector part. */
659 name = (char *) strchr(name+2, ' ');
660 if (regexp == NULL || re_exec(++name) != 0)
661 sym_arr[matches++] = (struct symbol *) msymbol;
665 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
667 /* Prevent compare on first iteration. */
669 for (ix = 0; ix < matches; ix++) /* Now do the output. */
674 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
675 name = strchr (name, ' ') + 1;
676 if (p[0] && specialcmp(name, p) == 0)
677 continue; /* Seen this one already (not unique). */
679 /* Copy selector part. */
680 while (*name && *name != ']')
683 /* Print in columns. */
684 puts_filtered_tabular(asel, maxlen + 1, 0);
689 printf_filtered (_("No selectors matching \"%s\"\n"),
690 regexp ? regexp : "*");
694 * Function: compare_classes (const void *, const void *)
696 * Comparison function for use with qsort. Arguments are symbols or
697 * msymbols Compares class part of objc method name alphabetically.
701 compare_classes (const void *a, const void *b)
703 const char *aname, *bname;
705 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
706 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
707 if (aname == NULL || bname == NULL)
708 error (_("internal: compare_classes(1)"));
710 return specialcmp (aname+1, bname+1);
714 * Function: classes_info(regexp, from_tty)
716 * Implements the "info classes" command for objective c classes.
717 * Lists all objective c classes that match the optional regexp.
718 * Works by grepping thru the list of objective c methods. List will
719 * be sorted and uniqued (since one class may have many methods).
720 * BUGS: will not list a class that has no methods.
724 classes_info (char *regexp, int from_tty)
726 struct objfile *objfile;
727 struct minimal_symbol *msymbol;
735 struct symbol **sym_arr;
738 strcpy(myregexp, ".* "); /* Null input: match all objc classes. */
741 /* Allow a few extra bytes because of the strcat below. */
742 if (sizeof (myregexp) < strlen (regexp) + 4)
743 error (_("Regexp is too long: %s"), regexp);
744 strcpy(myregexp, regexp);
745 if (myregexp[strlen(myregexp) - 1] == '$')
746 /* In the method name, the end of the class name is marked by ' '. */
747 myregexp[strlen(myregexp) - 1] = ' ';
749 strcat(myregexp, ".* ");
754 val = re_comp (myregexp);
756 error (_("Invalid regexp (%s): %s"), val, regexp);
759 /* First time thru is JUST to get max length and count. */
760 ALL_MSYMBOLS (objfile, msymbol)
763 name = MSYMBOL_NATURAL_NAME (msymbol);
765 (name[0] == '-' || name[0] == '+') &&
766 name[1] == '[') /* Got a method name. */
767 if (regexp == NULL || re_exec(name+2) != 0)
769 /* Compute length of classname part. */
770 const char *mystart = name + 2;
771 const char *myend = strchr (mystart, ' ');
773 if (myend && (myend - mystart > maxlen))
774 maxlen = myend - mystart;
780 printf_filtered (_("Classes matching \"%s\":\n\n"),
781 regexp ? regexp : "*");
782 sym_arr = XALLOCAVEC (struct symbol *, matches);
784 ALL_MSYMBOLS (objfile, msymbol)
787 name = MSYMBOL_NATURAL_NAME (msymbol);
789 (name[0] == '-' || name[0] == '+') &&
790 name[1] == '[') /* Got a method name. */
791 if (regexp == NULL || re_exec(name+2) != 0)
792 sym_arr[matches++] = (struct symbol *) msymbol;
795 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
797 /* Prevent compare on first iteration. */
799 for (ix = 0; ix < matches; ix++) /* Now do the output. */
804 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
806 if (p[0] && specialcmp(name, p) == 0)
807 continue; /* Seen this one already (not unique). */
809 /* Copy class part of method name. */
810 while (*name && *name != ' ')
813 /* Print in columns. */
814 puts_filtered_tabular(aclass, maxlen + 1, 0);
819 printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*");
823 parse_selector (char *method, char **selector)
829 char *nselector = NULL;
831 gdb_assert (selector != NULL);
835 s1 = skip_spaces (s1);
841 s1 = skip_spaces (s1);
848 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
850 else if (isspace (*s2))
852 else if ((*s2 == '\0') || (*s2 == '\''))
860 s2 = skip_spaces (s2);
865 s2 = skip_spaces (s2);
868 if (selector != NULL)
869 *selector = nselector;
875 parse_method (char *method, char *type, char **theclass,
876 char **category, char **selector)
884 char *ncategory = NULL;
885 char *nselector = NULL;
887 gdb_assert (type != NULL);
888 gdb_assert (theclass != NULL);
889 gdb_assert (category != NULL);
890 gdb_assert (selector != NULL);
894 s1 = skip_spaces (s1);
900 s1 = skip_spaces (s1);
902 if ((s1[0] == '+') || (s1[0] == '-'))
905 s1 = skip_spaces (s1);
912 while (isalnum (*s1) || (*s1 == '_'))
916 s2 = skip_spaces (s2);
921 s2 = skip_spaces (s2);
923 while (isalnum (*s2) || (*s2 == '_'))
928 /* Truncate the class name now that we're not using the open paren. */
936 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
938 else if (isspace (*s2))
949 s2 = skip_spaces (s2);
955 s2 = skip_spaces (s2);
960 if (theclass != NULL)
962 if (category != NULL)
963 *category = ncategory;
964 if (selector != NULL)
965 *selector = nselector;
971 find_methods (char type, const char *theclass, const char *category,
972 const char *selector,
973 VEC (const_char_ptr) **symbol_names)
975 struct objfile *objfile = NULL;
977 const char *symname = NULL;
981 char *ncategory = NULL;
982 char *nselector = NULL;
984 static char *tmp = NULL;
985 static unsigned int tmplen = 0;
987 gdb_assert (symbol_names != NULL);
989 ALL_OBJFILES (objfile)
991 unsigned int *objc_csym;
992 struct minimal_symbol *msymbol = NULL;
994 /* The objfile_csym variable counts the number of ObjC methods
995 that this objfile defines. We save that count as a private
996 objfile data. If we have already determined that this objfile
997 provides no ObjC methods, we can skip it entirely. */
999 unsigned int objfile_csym = 0;
1001 objc_csym = (unsigned int *) objfile_data (objfile, objc_objfile_data);
1002 if (objc_csym != NULL && *objc_csym == 0)
1003 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1006 ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
1010 /* Check the symbol name first as this can be done entirely without
1011 sending any query to the target. */
1012 symname = MSYMBOL_NATURAL_NAME (msymbol);
1013 if (symname == NULL)
1016 if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1017 /* Not a method name. */
1022 /* Now that thinks are a bit sane, clean up the symname. */
1023 while ((strlen (symname) + 1) >= tmplen)
1025 tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1026 tmp = (char *) xrealloc (tmp, tmplen);
1028 strcpy (tmp, symname);
1030 if (parse_method (tmp, &ntype, &nclass,
1031 &ncategory, &nselector) == NULL)
1034 if ((type != '\0') && (ntype != type))
1037 if ((theclass != NULL)
1038 && ((nclass == NULL) || (strcmp (theclass, nclass) != 0)))
1041 if ((category != NULL) &&
1042 ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1045 if ((selector != NULL) &&
1046 ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1049 VEC_safe_push (const_char_ptr, *symbol_names, symname);
1052 if (objc_csym == NULL)
1054 objc_csym = XOBNEW (&objfile->objfile_obstack, unsigned int);
1055 *objc_csym = objfile_csym;
1056 set_objfile_data (objfile, objc_objfile_data, objc_csym);
1059 /* Count of ObjC methods in this objfile should be constant. */
1060 gdb_assert (*objc_csym == objfile_csym);
1064 /* Uniquify a VEC of strings. */
1067 uniquify_strings (VEC (const_char_ptr) **strings)
1070 const char *elem, *last = NULL;
1073 /* If the vector is empty, there's nothing to do. This explicit
1074 check is needed to avoid invoking qsort with NULL. */
1075 if (VEC_empty (const_char_ptr, *strings))
1078 qsort (VEC_address (const_char_ptr, *strings),
1079 VEC_length (const_char_ptr, *strings),
1080 sizeof (const_char_ptr),
1083 for (ix = 0; VEC_iterate (const_char_ptr, *strings, ix, elem); ++ix)
1085 if (last == NULL || strcmp (last, elem) != 0)
1088 VEC_replace (const_char_ptr, *strings, out, elem);
1093 VEC_truncate (const_char_ptr, *strings, out);
1097 * Function: find_imps (const char *selector, struct symbol **sym_arr)
1099 * Input: a string representing a selector
1100 * a pointer to an array of symbol pointers
1101 * possibly a pointer to a symbol found by the caller.
1103 * Output: number of methods that implement that selector. Side
1104 * effects: The array of symbol pointers is filled with matching syms.
1106 * By analogy with function "find_methods" (symtab.c), builds a list
1107 * of symbols matching the ambiguous input, so that "decode_line_2"
1108 * (symtab.c) can list them and ask the user to choose one or more.
1109 * In this case the matches are objective c methods
1110 * ("implementations") matching an objective c selector.
1112 * Note that it is possible for a normal (c-style) function to have
1113 * the same name as an objective c selector. To prevent the selector
1114 * from eclipsing the function, we allow the caller (decode_line_1) to
1115 * search for such a function first, and if it finds one, pass it in
1116 * to us. We will then integrate it into the list. We also search
1117 * for one here, among the minsyms.
1119 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1120 * into two parts: debuggable (struct symbol) syms, and
1121 * non_debuggable (struct minimal_symbol) syms. The debuggable
1122 * ones will come first, before NUM_DEBUGGABLE (which will thus
1123 * be the index of the first non-debuggable one).
1127 find_imps (const char *method, VEC (const_char_ptr) **symbol_names)
1130 char *theclass = NULL;
1131 char *category = NULL;
1132 char *selector = NULL;
1137 int selector_case = 0;
1139 gdb_assert (symbol_names != NULL);
1141 buf = (char *) alloca (strlen (method) + 1);
1142 strcpy (buf, method);
1143 tmp = parse_method (buf, &type, &theclass, &category, &selector);
1147 strcpy (buf, method);
1148 tmp = parse_selector (buf, &selector);
1156 find_methods (type, theclass, category, selector, symbol_names);
1158 /* If we hit the "selector" case, and we found some methods, then
1159 add the selector itself as a symbol, if it exists. */
1160 if (selector_case && !VEC_empty (const_char_ptr, *symbol_names))
1162 struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN,
1166 VEC_safe_push (const_char_ptr, *symbol_names,
1167 SYMBOL_NATURAL_NAME (sym));
1170 struct bound_minimal_symbol msym
1171 = lookup_minimal_symbol (selector, 0, 0);
1173 if (msym.minsym != NULL)
1174 VEC_safe_push (const_char_ptr, *symbol_names,
1175 MSYMBOL_NATURAL_NAME (msym.minsym));
1179 uniquify_strings (symbol_names);
1181 return method + (tmp - buf);
1185 print_object_command (char *args, int from_tty)
1187 struct value *object, *function, *description;
1188 CORE_ADDR string_addr, object_addr;
1192 if (!args || !*args)
1194 "The 'print-object' command requires an argument (an Objective-C object)");
1197 expression_up expr = parse_expression (args);
1200 object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1201 expr.get (), &pc, EVAL_NORMAL);
1204 /* Validate the address for sanity. */
1205 object_addr = value_as_long (object);
1206 read_memory (object_addr, &c, 1);
1208 function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1209 if (function == NULL)
1210 error (_("Unable to locate _NSPrintForDebugger in child process"));
1212 description = call_function_by_hand (function, 1, &object);
1214 string_addr = value_as_long (description);
1215 if (string_addr == 0)
1216 error (_("object returns null description"));
1218 read_memory (string_addr + i++, &c, 1);
1221 { /* Read and print characters up to EOS. */
1223 printf_filtered ("%c", c);
1224 read_memory (string_addr + i++, &c, 1);
1227 printf_filtered(_("<object returns empty description>"));
1228 printf_filtered ("\n");
1231 /* The data structure 'methcalls' is used to detect method calls (thru
1232 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1233 * and ultimately find the method being called.
1236 struct objc_methcall {
1238 /* Return instance method to be called. */
1239 int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1240 /* Start of pc range corresponding to method invocation. */
1242 /* End of pc range corresponding to method invocation. */
1246 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1247 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1248 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1249 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1251 static struct objc_methcall methcalls[] = {
1252 { "_objc_msgSend", resolve_msgsend, 0, 0},
1253 { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1254 { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1255 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1256 { "_objc_getClass", NULL, 0, 0},
1257 { "_objc_getMetaClass", NULL, 0, 0}
1260 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1262 /* The following function, "find_objc_msgsend", fills in the data
1263 * structure "objc_msgs" by finding the addresses of each of the
1264 * (currently four) functions that it holds (of which objc_msgSend is
1265 * the first). This must be called each time symbols are loaded, in
1266 * case the functions have moved for some reason.
1270 find_objc_msgsend (void)
1274 for (i = 0; i < nmethcalls; i++)
1276 struct bound_minimal_symbol func;
1278 /* Try both with and without underscore. */
1279 func = lookup_bound_minimal_symbol (methcalls[i].name);
1280 if ((func.minsym == NULL) && (methcalls[i].name[0] == '_'))
1282 func = lookup_bound_minimal_symbol (methcalls[i].name + 1);
1284 if (func.minsym == NULL)
1286 methcalls[i].begin = 0;
1287 methcalls[i].end = 0;
1291 methcalls[i].begin = BMSYMBOL_VALUE_ADDRESS (func);
1292 methcalls[i].end = minimal_symbol_upper_bound (func);
1296 /* find_objc_msgcall (replaces pc_off_limits)
1298 * ALL that this function now does is to determine whether the input
1299 * address ("pc") is the address of one of the Objective-C message
1300 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1301 * if so, it returns the address of the method that will be called.
1303 * The old function "pc_off_limits" used to do a lot of other things
1304 * in addition, such as detecting shared library jump stubs and
1305 * returning the address of the shlib function that would be called.
1306 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1307 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1308 * dependent modules.
1311 struct objc_submethod_helper_data {
1312 int (*f) (CORE_ADDR, CORE_ADDR *);
1318 find_objc_msgcall_submethod_helper (void * arg)
1320 struct objc_submethod_helper_data *s =
1321 (struct objc_submethod_helper_data *) arg;
1323 if (s->f (s->pc, s->new_pc) == 0)
1330 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1334 struct objc_submethod_helper_data s;
1340 if (catch_errors (find_objc_msgcall_submethod_helper,
1342 "Unable to determine target of "
1343 "Objective-C method call (ignoring):\n",
1344 RETURN_MASK_ALL) == 0)
1351 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1355 find_objc_msgsend ();
1361 for (i = 0; i < nmethcalls; i++)
1362 if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1364 if (methcalls[i].stop_at != NULL)
1365 return find_objc_msgcall_submethod (methcalls[i].stop_at,
1374 /* -Wmissing-prototypes */
1375 extern initialize_file_ftype _initialize_objc_language;
1378 _initialize_objc_language (void)
1380 add_language (&objc_language_defn);
1381 add_info ("selectors", selectors_info, /* INFO SELECTORS command. */
1382 _("All Objective-C selectors, or those matching REGEXP."));
1383 add_info ("classes", classes_info, /* INFO CLASSES command. */
1384 _("All Objective-C classes, or those matching REGEXP."));
1385 add_com ("print-object", class_vars, print_object_command,
1386 _("Ask an Objective-C object to print itself."));
1387 add_com_alias ("po", "print-object", class_vars, 1);
1391 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1392 struct objc_method *method)
1394 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1396 method->name = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1397 method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1398 method->imp = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1401 static unsigned long
1402 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1404 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1406 return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1410 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1411 unsigned long num, struct objc_method *method)
1413 gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1414 read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1418 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1419 struct objc_object *object)
1421 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1423 object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1427 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1428 struct objc_super *super)
1430 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1432 super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1433 super->theclass = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1437 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1438 struct objc_class *theclass)
1440 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1442 theclass->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1443 theclass->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1444 theclass->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1445 theclass->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1446 theclass->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
1447 theclass->instance_size = read_memory_unsigned_integer (addr + 18, 4,
1449 theclass->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1450 theclass->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1451 theclass->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1452 theclass->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1456 find_implementation_from_class (struct gdbarch *gdbarch,
1457 CORE_ADDR theclass, CORE_ADDR sel)
1459 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1460 CORE_ADDR subclass = theclass;
1462 while (subclass != 0)
1465 struct objc_class class_str;
1466 unsigned mlistnum = 0;
1468 read_objc_class (gdbarch, subclass, &class_str);
1473 unsigned long nmethods;
1476 mlist = read_memory_unsigned_integer (class_str.methods +
1482 nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1484 for (i = 0; i < nmethods; i++)
1486 struct objc_method meth_str;
1488 read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
1490 if (meth_str.name == sel)
1491 /* FIXME: hppa arch was doing a pointer dereference
1492 here. There needs to be a better way to do that. */
1493 return meth_str.imp;
1497 subclass = class_str.super_class;
1504 find_implementation (struct gdbarch *gdbarch,
1505 CORE_ADDR object, CORE_ADDR sel)
1507 struct objc_object ostr;
1511 read_objc_object (gdbarch, object, &ostr);
1515 return find_implementation_from_class (gdbarch, ostr.isa, sel);
1519 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1521 struct frame_info *frame = get_current_frame ();
1522 struct gdbarch *gdbarch = get_frame_arch (frame);
1523 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1529 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1530 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1532 res = find_implementation (gdbarch, object, sel);
1541 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1543 struct frame_info *frame = get_current_frame ();
1544 struct gdbarch *gdbarch = get_frame_arch (frame);
1545 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1551 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1552 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1554 res = find_implementation (gdbarch, object, sel);
1563 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1565 struct frame_info *frame = get_current_frame ();
1566 struct gdbarch *gdbarch = get_frame_arch (frame);
1567 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1569 struct objc_super sstr;
1575 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1576 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1578 read_objc_super (gdbarch, super, &sstr);
1579 if (sstr.theclass == 0)
1582 res = find_implementation_from_class (gdbarch, sstr.theclass, sel);
1591 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1593 struct frame_info *frame = get_current_frame ();
1594 struct gdbarch *gdbarch = get_frame_arch (frame);
1595 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1597 struct objc_super sstr;
1603 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1604 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1606 read_objc_super (gdbarch, super, &sstr);
1607 if (sstr.theclass == 0)
1610 res = find_implementation_from_class (gdbarch, sstr.theclass, sel);
1618 /* Provide a prototype to silence -Wmissing-prototypes. */
1619 extern initialize_file_ftype _initialize_objc_lang;
1622 _initialize_objc_lang (void)
1624 objc_objfile_data = register_objfile_data ();