1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 Contributed by Apple Computer, Inc.
7 Written by Michael Snyder.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "expression.h"
28 #include "parser-defs.h"
31 #include "objc-lang.h"
32 #include "exceptions.h"
33 #include "complaints.h"
37 #include "gdb_string.h" /* for strchr */
38 #include "target.h" /* for target_has_execution */
42 #include "gdb_regex.h"
47 #include "gdb_assert.h"
57 CORE_ADDR super_class
;
79 static const struct objfile_data
*objc_objfile_data
;
81 /* Lookup a structure type named "struct NAME", visible in lexical
82 block BLOCK. If NOERR is nonzero, return zero if NAME is not
86 lookup_struct_typedef (char *name
, struct block
*block
, int noerr
)
90 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0);
97 error (_("No struct type named %s."), name
);
99 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
104 error (_("This context has class, union or enum %s, not a struct."),
111 lookup_objc_class (struct gdbarch
*gdbarch
, char *classname
)
113 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
114 struct value
* function
, *classval
;
116 if (! target_has_execution
)
118 /* Can't call into inferior to lookup class. */
122 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
123 function
= find_function_in_inferior("objc_lookUpClass", NULL
);
124 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
125 function
= find_function_in_inferior("objc_lookup_class", NULL
);
128 complaint (&symfile_complaints
,
129 _("no way to lookup Objective-C classes"));
133 classval
= value_string (classname
, strlen (classname
) + 1, char_type
);
134 classval
= value_coerce_array (classval
);
135 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
140 lookup_child_selector (struct gdbarch
*gdbarch
, char *selname
)
142 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
143 struct value
* function
, *selstring
;
145 if (! target_has_execution
)
147 /* Can't call into inferior to lookup selector. */
151 if (lookup_minimal_symbol("sel_getUid", 0, 0))
152 function
= find_function_in_inferior("sel_getUid", NULL
);
153 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
154 function
= find_function_in_inferior("sel_get_any_uid", NULL
);
157 complaint (&symfile_complaints
,
158 _("no way to lookup Objective-C selectors"));
162 selstring
= value_coerce_array (value_string (selname
,
163 strlen (selname
) + 1,
165 return value_as_long (call_function_by_hand (function
, 1, &selstring
));
169 value_nsstring (struct gdbarch
*gdbarch
, char *ptr
, int len
)
171 struct type
*char_type
= builtin_type (gdbarch
)->builtin_char
;
172 struct value
*stringValue
[3];
173 struct value
*function
, *nsstringValue
;
177 if (!target_has_execution
)
178 return 0; /* Can't call into inferior to create NSString. */
180 stringValue
[2] = value_string(ptr
, len
, char_type
);
181 stringValue
[2] = value_coerce_array(stringValue
[2]);
182 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
183 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
185 function
= find_function_in_inferior("_NSNewStringFromCString", NULL
);
186 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
188 else if (lookup_minimal_symbol("istr", 0, 0))
190 function
= find_function_in_inferior("istr", NULL
);
191 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
193 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
196 = find_function_in_inferior("+[NSString stringWithCString:]", NULL
);
197 type
= builtin_type (gdbarch
)->builtin_long
;
199 stringValue
[0] = value_from_longest
200 (type
, lookup_objc_class (gdbarch
, "NSString"));
201 stringValue
[1] = value_from_longest
202 (type
, lookup_child_selector (gdbarch
, "stringWithCString:"));
203 nsstringValue
= call_function_by_hand(function
, 3, &stringValue
[0]);
206 error (_("NSString: internal error -- no way to create new NSString"));
208 sym
= lookup_struct_typedef("NSString", 0, 1);
210 sym
= lookup_struct_typedef("NXString", 0, 1);
212 type
= builtin_type (gdbarch
)->builtin_data_ptr
;
214 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
216 deprecated_set_value_type (nsstringValue
, type
);
217 return nsstringValue
;
220 /* Objective-C name demangling. */
223 objc_demangle (const char *mangled
, int options
)
225 char *demangled
, *cp
;
227 if (mangled
[0] == '_' &&
228 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
231 cp
= demangled
= xmalloc(strlen(mangled
) + 2);
233 if (mangled
[1] == 'i')
234 *cp
++ = '-'; /* for instance method */
236 *cp
++ = '+'; /* for class method */
238 *cp
++ = '['; /* opening left brace */
239 strcpy(cp
, mangled
+3); /* Tack on the rest of the mangled name. */
241 while (*cp
&& *cp
== '_')
242 cp
++; /* Skip any initial underbars in class
245 cp
= strchr(cp
, '_');
246 if (!cp
) /* Find first non-initial underbar. */
248 xfree(demangled
); /* not mangled name */
251 if (cp
[1] == '_') /* Easy case: no category name. */
253 *cp
++ = ' '; /* Replace two '_' with one ' '. */
254 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
258 *cp
++ = '('; /* Less easy case: category name. */
259 cp
= strchr(cp
, '_');
262 xfree(demangled
); /* not mangled name */
266 *cp
++ = ' '; /* Overwriting 1st char of method name... */
267 strcpy(cp
, mangled
+ (cp
- demangled
)); /* Get it back. */
270 while (*cp
&& *cp
== '_')
271 cp
++; /* Skip any initial underbars in
276 *cp
= ':'; /* Replace remaining '_' with ':'. */
278 *cp
++ = ']'; /* closing right brace */
279 *cp
++ = 0; /* string terminator */
283 return NULL
; /* Not an objc mangled name. */
286 /* Print the character C on STREAM as part of the contents of a
287 literal string whose delimiter is QUOTER. Note that that format
288 for printing characters and strings is language specific. */
291 objc_emit_char (int c
, struct type
*type
, struct ui_file
*stream
, int quoter
)
293 c
&= 0xFF; /* Avoid sign bit follies. */
295 if (PRINT_LITERAL_FORM (c
))
297 if (c
== '\\' || c
== quoter
)
299 fputs_filtered ("\\", stream
);
301 fprintf_filtered (stream
, "%c", c
);
308 fputs_filtered ("\\n", stream
);
311 fputs_filtered ("\\b", stream
);
314 fputs_filtered ("\\t", stream
);
317 fputs_filtered ("\\f", stream
);
320 fputs_filtered ("\\r", stream
);
323 fputs_filtered ("\\e", stream
);
326 fputs_filtered ("\\a", stream
);
329 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
336 objc_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
338 fputs_filtered ("'", stream
);
339 objc_emit_char (c
, type
, stream
, '\'');
340 fputs_filtered ("'", stream
);
343 /* Print the character string STRING, printing at most LENGTH
344 characters. Printing stops early if the number hits print_max;
345 repeat counts are printed as appropriate. Print ellipses at the
346 end if we had to stop before printing LENGTH characters, or if
350 objc_printstr (struct ui_file
*stream
, struct type
*type
,
351 const gdb_byte
*string
, unsigned int length
,
352 const char *encoding
, int force_ellipses
,
353 const struct value_print_options
*options
)
356 unsigned int things_printed
= 0;
360 /* If the string was not truncated due to `set print elements', and
361 the last byte of it is a null, we don't print that, in
362 traditional C style. */
363 if ((!force_ellipses
) && length
> 0 && string
[length
-1] == '\0')
368 fputs_filtered ("\"\"", stream
);
372 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; ++i
)
374 /* Position of the character we are examining to see whether it
377 /* Number of repetitions we have detected so far. */
384 fputs_filtered (", ", stream
);
390 while (rep1
< length
&& string
[rep1
] == string
[i
])
396 if (reps
> options
->repeat_count_threshold
)
400 if (options
->inspect_it
)
401 fputs_filtered ("\\\", ", stream
);
403 fputs_filtered ("\", ", stream
);
406 objc_printchar (string
[i
], type
, stream
);
407 fprintf_filtered (stream
, " <repeats %u times>", reps
);
409 things_printed
+= options
->repeat_count_threshold
;
416 if (options
->inspect_it
)
417 fputs_filtered ("\\\"", stream
);
419 fputs_filtered ("\"", stream
);
422 objc_emit_char (string
[i
], type
, stream
, '"');
427 /* Terminate the quotes if necessary. */
430 if (options
->inspect_it
)
431 fputs_filtered ("\\\"", stream
);
433 fputs_filtered ("\"", stream
);
436 if (force_ellipses
|| i
< length
)
437 fputs_filtered ("...", stream
);
440 /* Determine if we are currently in the Objective-C dispatch function.
441 If so, get the address of the method function that the dispatcher
442 would call and use that as the function to step into instead. Also
443 skip over the trampoline for the function (if any). This is better
444 for the user since they are only interested in stepping into the
445 method function anyway. */
447 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
449 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
450 CORE_ADDR real_stop_pc
;
451 CORE_ADDR method_stop_pc
;
453 real_stop_pc
= gdbarch_skip_trampoline_code (gdbarch
, frame
, stop_pc
);
455 if (real_stop_pc
!= 0)
456 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
458 find_objc_msgcall (stop_pc
, &method_stop_pc
);
462 real_stop_pc
= gdbarch_skip_trampoline_code
463 (gdbarch
, frame
, method_stop_pc
);
464 if (real_stop_pc
== 0)
465 real_stop_pc
= method_stop_pc
;
472 /* Table mapping opcodes into strings for printing operators
473 and precedences of the operators. */
475 static const struct op_print objc_op_print_tab
[] =
477 {",", BINOP_COMMA
, PREC_COMMA
, 0},
478 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
479 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
480 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
481 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
482 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
483 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
484 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
485 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
486 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
487 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
488 {">", BINOP_GTR
, PREC_ORDER
, 0},
489 {"<", BINOP_LESS
, PREC_ORDER
, 0},
490 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
491 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
492 {"+", BINOP_ADD
, PREC_ADD
, 0},
493 {"-", BINOP_SUB
, PREC_ADD
, 0},
494 {"*", BINOP_MUL
, PREC_MUL
, 0},
495 {"/", BINOP_DIV
, PREC_MUL
, 0},
496 {"%", BINOP_REM
, PREC_MUL
, 0},
497 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
498 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
499 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
500 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
501 {"*", UNOP_IND
, PREC_PREFIX
, 0},
502 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
503 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
504 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
505 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
506 {NULL
, OP_NULL
, PREC_NULL
, 0}
509 const struct language_defn objc_language_defn
= {
510 "objective-c", /* Language name */
517 &exp_descriptor_standard
,
521 objc_printchar
, /* Print a character constant */
522 objc_printstr
, /* Function to print string constant */
524 c_print_type
, /* Print a type using appropriate syntax */
525 c_print_typedef
, /* Print a typedef using appropriate syntax */
526 c_val_print
, /* Print a value using appropriate syntax */
527 c_value_print
, /* Print a top-level value */
528 objc_skip_trampoline
, /* Language specific skip_trampoline */
529 "self", /* name_of_this */
530 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
531 basic_lookup_transparent_type
,/* lookup_transparent_type */
532 objc_demangle
, /* Language specific symbol demangler */
533 NULL
, /* Language specific
534 class_name_from_physname */
535 objc_op_print_tab
, /* Expression operators for printing */
536 1, /* C-style arrays */
537 0, /* String lower bound */
538 default_word_break_characters
,
539 default_make_symbol_completion_list
,
540 c_language_arch_info
,
541 default_print_array_index
,
542 default_pass_by_reference
,
549 * Following functions help construct Objective-C message calls.
552 struct selname
/* For parsing Objective-C. */
554 struct selname
*next
;
559 static int msglist_len
;
560 static struct selname
*selname_chain
;
561 static char *msglist_sel
;
566 struct selname
*new =
567 (struct selname
*) xmalloc (sizeof (struct selname
));
569 new->next
= selname_chain
;
570 new->msglist_len
= msglist_len
;
571 new->msglist_sel
= msglist_sel
;
573 msglist_sel
= (char *)xmalloc(1);
579 add_msglist(struct stoken
*str
, int addcolon
)
584 if (str
== 0) /* Unnamed arg, or... */
586 if (addcolon
== 0) /* variable number of args. */
599 len
= plen
+ strlen(msglist_sel
) + 2;
600 s
= (char *)xmalloc(len
);
601 strcpy(s
, msglist_sel
);
618 int val
= msglist_len
;
619 struct selname
*sel
= selname_chain
;
620 char *p
= msglist_sel
;
623 selname_chain
= sel
->next
;
624 msglist_len
= sel
->msglist_len
;
625 msglist_sel
= sel
->msglist_sel
;
626 selid
= lookup_child_selector (parse_gdbarch
, p
);
628 error (_("Can't find selector \"%s\""), p
);
629 write_exp_elt_longcst (selid
);
631 write_exp_elt_longcst (val
); /* Number of args */
638 * Function: specialcmp (char *a, char *b)
640 * Special strcmp: treats ']' and ' ' as end-of-string.
641 * Used for qsorting lists of objc methods (either by class or selector).
645 specialcmp (char *a
, char *b
)
647 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
653 if (*a
&& *a
!= ' ' && *a
!= ']')
654 return 1; /* a is longer therefore greater. */
655 if (*b
&& *b
!= ' ' && *b
!= ']')
656 return -1; /* a is shorter therefore lesser. */
657 return 0; /* a and b are identical. */
661 * Function: compare_selectors (const void *, const void *)
663 * Comparison function for use with qsort. Arguments are symbols or
664 * msymbols Compares selector part of objc method name alphabetically.
668 compare_selectors (const void *a
, const void *b
)
672 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
673 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
674 if (aname
== NULL
|| bname
== NULL
)
675 error (_("internal: compare_selectors(1)"));
677 aname
= strchr(aname
, ' ');
678 bname
= strchr(bname
, ' ');
679 if (aname
== NULL
|| bname
== NULL
)
680 error (_("internal: compare_selectors(2)"));
682 return specialcmp (aname
+1, bname
+1);
686 * Function: selectors_info (regexp, from_tty)
688 * Implements the "Info selectors" command. Takes an optional regexp
689 * arg. Lists all objective c selectors that match the regexp. Works
690 * by grepping thru all symbols for objective c methods. Output list
691 * is sorted and uniqued.
695 selectors_info (char *regexp
, int from_tty
)
697 struct objfile
*objfile
;
698 struct minimal_symbol
*msymbol
;
706 struct symbol
**sym_arr
;
710 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
713 if (*regexp
== '+' || *regexp
== '-')
714 { /* User wants only class methods or only instance methods. */
715 plusminus
= *regexp
++;
716 while (*regexp
== ' ' || *regexp
== '\t')
720 strcpy(myregexp
, ".*]");
723 /* Allow a few extra bytes because of the strcat below. */
724 if (sizeof (myregexp
) < strlen (regexp
) + 4)
725 error (_("Regexp is too long: %s"), regexp
);
726 strcpy(myregexp
, regexp
);
727 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
728 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
730 strcat(myregexp
, ".*]");
736 val
= re_comp (myregexp
);
738 error (_("Invalid regexp (%s): %s"), val
, regexp
);
741 /* First time thru is JUST to get max length and count. */
742 ALL_MSYMBOLS (objfile
, msymbol
)
745 name
= SYMBOL_NATURAL_NAME (msymbol
);
747 && (name
[0] == '-' || name
[0] == '+')
748 && name
[1] == '[') /* Got a method name. */
750 /* Filter for class/instance methods. */
751 if (plusminus
&& name
[0] != plusminus
)
753 /* Find selector part. */
754 name
= (char *) strchr (name
+2, ' ');
757 complaint (&symfile_complaints
,
758 _("Bad method name '%s'"),
759 SYMBOL_NATURAL_NAME (msymbol
));
762 if (regexp
== NULL
|| re_exec(++name
) != 0)
764 char *mystart
= name
;
765 char *myend
= (char *) strchr (mystart
, ']');
767 if (myend
&& (myend
- mystart
> maxlen
))
768 maxlen
= myend
- mystart
; /* Get longest selector. */
775 printf_filtered (_("Selectors matching \"%s\":\n\n"),
776 regexp
? regexp
: "*");
778 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
780 ALL_MSYMBOLS (objfile
, msymbol
)
783 name
= SYMBOL_NATURAL_NAME (msymbol
);
785 (name
[0] == '-' || name
[0] == '+') &&
786 name
[1] == '[') /* Got a method name. */
788 /* Filter for class/instance methods. */
789 if (plusminus
&& name
[0] != plusminus
)
791 /* Find selector part. */
792 name
= (char *) strchr(name
+2, ' ');
793 if (regexp
== NULL
|| re_exec(++name
) != 0)
794 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
798 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
800 /* Prevent compare on first iteration. */
802 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
807 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
808 name
= strchr (name
, ' ') + 1;
809 if (p
[0] && specialcmp(name
, p
) == 0)
810 continue; /* Seen this one already (not unique). */
812 /* Copy selector part. */
813 while (*name
&& *name
!= ']')
816 /* Print in columns. */
817 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
822 printf_filtered (_("No selectors matching \"%s\"\n"),
823 regexp
? regexp
: "*");
827 * Function: compare_classes (const void *, const void *)
829 * Comparison function for use with qsort. Arguments are symbols or
830 * msymbols Compares class part of objc method name alphabetically.
834 compare_classes (const void *a
, const void *b
)
838 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
839 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
840 if (aname
== NULL
|| bname
== NULL
)
841 error (_("internal: compare_classes(1)"));
843 return specialcmp (aname
+1, bname
+1);
847 * Function: classes_info(regexp, from_tty)
849 * Implements the "info classes" command for objective c classes.
850 * Lists all objective c classes that match the optional regexp.
851 * Works by grepping thru the list of objective c methods. List will
852 * be sorted and uniqued (since one class may have many methods).
853 * BUGS: will not list a class that has no methods.
857 classes_info (char *regexp
, int from_tty
)
859 struct objfile
*objfile
;
860 struct minimal_symbol
*msymbol
;
868 struct symbol
**sym_arr
;
871 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
874 /* Allow a few extra bytes because of the strcat below. */
875 if (sizeof (myregexp
) < strlen (regexp
) + 4)
876 error (_("Regexp is too long: %s"), regexp
);
877 strcpy(myregexp
, regexp
);
878 if (myregexp
[strlen(myregexp
) - 1] == '$')
879 /* In the method name, the end of the class name is marked by ' '. */
880 myregexp
[strlen(myregexp
) - 1] = ' ';
882 strcat(myregexp
, ".* ");
887 val
= re_comp (myregexp
);
889 error (_("Invalid regexp (%s): %s"), val
, regexp
);
892 /* First time thru is JUST to get max length and count. */
893 ALL_MSYMBOLS (objfile
, msymbol
)
896 name
= SYMBOL_NATURAL_NAME (msymbol
);
898 (name
[0] == '-' || name
[0] == '+') &&
899 name
[1] == '[') /* Got a method name. */
900 if (regexp
== NULL
|| re_exec(name
+2) != 0)
902 /* Compute length of classname part. */
903 char *mystart
= name
+ 2;
904 char *myend
= (char *) strchr(mystart
, ' ');
906 if (myend
&& (myend
- mystart
> maxlen
))
907 maxlen
= myend
- mystart
;
913 printf_filtered (_("Classes matching \"%s\":\n\n"),
914 regexp
? regexp
: "*");
915 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
917 ALL_MSYMBOLS (objfile
, msymbol
)
920 name
= SYMBOL_NATURAL_NAME (msymbol
);
922 (name
[0] == '-' || name
[0] == '+') &&
923 name
[1] == '[') /* Got a method name. */
924 if (regexp
== NULL
|| re_exec(name
+2) != 0)
925 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
928 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
930 /* Prevent compare on first iteration. */
932 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
937 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
939 if (p
[0] && specialcmp(name
, p
) == 0)
940 continue; /* Seen this one already (not unique). */
942 /* Copy class part of method name. */
943 while (*name
&& *name
!= ' ')
946 /* Print in columns. */
947 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
952 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
956 * Function: find_imps (char *selector, struct symbol **sym_arr)
958 * Input: a string representing a selector
959 * a pointer to an array of symbol pointers
960 * possibly a pointer to a symbol found by the caller.
962 * Output: number of methods that implement that selector. Side
963 * effects: The array of symbol pointers is filled with matching syms.
965 * By analogy with function "find_methods" (symtab.c), builds a list
966 * of symbols matching the ambiguous input, so that "decode_line_2"
967 * (symtab.c) can list them and ask the user to choose one or more.
968 * In this case the matches are objective c methods
969 * ("implementations") matching an objective c selector.
971 * Note that it is possible for a normal (c-style) function to have
972 * the same name as an objective c selector. To prevent the selector
973 * from eclipsing the function, we allow the caller (decode_line_1) to
974 * search for such a function first, and if it finds one, pass it in
975 * to us. We will then integrate it into the list. We also search
976 * for one here, among the minsyms.
978 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
979 * into two parts: debuggable (struct symbol) syms, and
980 * non_debuggable (struct minimal_symbol) syms. The debuggable
981 * ones will come first, before NUM_DEBUGGABLE (which will thus
982 * be the index of the first non-debuggable one).
986 * Function: total_number_of_imps (char *selector);
988 * Input: a string representing a selector
989 * Output: number of methods that implement that selector.
991 * By analogy with function "total_number_of_methods", this allows
992 * decode_line_1 (symtab.c) to detect if there are objective c methods
993 * matching the input, and to allocate an array of pointers to them
994 * which can be manipulated by "decode_line_2" (also in symtab.c).
998 parse_selector (char *method
, char **selector
)
1002 int found_quote
= 0;
1004 char *nselector
= NULL
;
1006 gdb_assert (selector
!= NULL
);
1010 while (isspace (*s1
))
1017 while (isspace (*s1
))
1025 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1027 else if (isspace (*s2
))
1029 else if ((*s2
== '\0') || (*s2
== '\''))
1037 while (isspace (*s2
))
1043 while (isspace (*s2
))
1047 if (selector
!= NULL
)
1048 *selector
= nselector
;
1054 parse_method (char *method
, char *type
, char **class,
1055 char **category
, char **selector
)
1059 int found_quote
= 0;
1062 char *nclass
= NULL
;
1063 char *ncategory
= NULL
;
1064 char *nselector
= NULL
;
1066 gdb_assert (type
!= NULL
);
1067 gdb_assert (class != NULL
);
1068 gdb_assert (category
!= NULL
);
1069 gdb_assert (selector
!= NULL
);
1073 while (isspace (*s1
))
1080 while (isspace (*s1
))
1083 if ((s1
[0] == '+') || (s1
[0] == '-'))
1086 while (isspace (*s1
))
1094 while (isalnum (*s1
) || (*s1
== '_'))
1098 while (isspace (*s2
))
1104 while (isspace (*s2
))
1107 while (isalnum (*s2
) || (*s2
== '_'))
1112 /* Truncate the class name now that we're not using the open paren. */
1120 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1122 else if (isspace (*s2
))
1124 else if (*s2
== ']')
1133 while (isspace (*s2
))
1140 while (isspace (*s2
))
1148 if (category
!= NULL
)
1149 *category
= ncategory
;
1150 if (selector
!= NULL
)
1151 *selector
= nselector
;
1157 find_methods (struct symtab
*symtab
, char type
,
1158 const char *class, const char *category
,
1159 const char *selector
, struct symbol
**syms
,
1160 unsigned int *nsym
, unsigned int *ndebug
)
1162 struct objfile
*objfile
= NULL
;
1163 struct minimal_symbol
*msymbol
= NULL
;
1164 struct block
*block
= NULL
;
1165 struct symbol
*sym
= NULL
;
1167 char *symname
= NULL
;
1170 char *nclass
= NULL
;
1171 char *ncategory
= NULL
;
1172 char *nselector
= NULL
;
1174 unsigned int csym
= 0;
1175 unsigned int cdebug
= 0;
1177 static char *tmp
= NULL
;
1178 static unsigned int tmplen
= 0;
1180 gdb_assert (nsym
!= NULL
);
1181 gdb_assert (ndebug
!= NULL
);
1184 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1186 ALL_OBJFILES (objfile
)
1188 unsigned int *objc_csym
;
1190 /* The objfile_csym variable counts the number of ObjC methods
1191 that this objfile defines. We save that count as a private
1192 objfile data. If we have already determined that this objfile
1193 provides no ObjC methods, we can skip it entirely. */
1195 unsigned int objfile_csym
= 0;
1197 objc_csym
= objfile_data (objfile
, objc_objfile_data
);
1198 if (objc_csym
!= NULL
&& *objc_csym
== 0)
1199 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1202 ALL_OBJFILE_MSYMBOLS (objfile
, msymbol
)
1204 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
1205 CORE_ADDR pc
= SYMBOL_VALUE_ADDRESS (msymbol
);
1209 /* Check the symbol name first as this can be done entirely without
1210 sending any query to the target. */
1211 symname
= SYMBOL_NATURAL_NAME (msymbol
);
1212 if (symname
== NULL
)
1215 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1216 /* Not a method name. */
1219 /* The minimal symbol might point to a function descriptor;
1220 resolve it to the actual code address instead. */
1221 pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
, pc
,
1225 if (pc
< BLOCK_START (block
) || pc
>= BLOCK_END (block
))
1226 /* Not in the specified symtab. */
1229 /* Now that thinks are a bit sane, clean up the symname. */
1230 while ((strlen (symname
) + 1) >= tmplen
)
1232 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1233 tmp
= xrealloc (tmp
, tmplen
);
1235 strcpy (tmp
, symname
);
1237 if (parse_method (tmp
, &ntype
, &nclass
,
1238 &ncategory
, &nselector
) == NULL
)
1243 if ((type
!= '\0') && (ntype
!= type
))
1247 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1250 if ((category
!= NULL
) &&
1251 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1254 if ((selector
!= NULL
) &&
1255 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1258 sym
= find_pc_function (pc
);
1261 const char *newsymname
= SYMBOL_NATURAL_NAME (sym
);
1263 if (strcmp (symname
, newsymname
) == 0)
1265 /* Found a high-level method sym: swap it into the
1266 lower part of sym_arr (below num_debuggable). */
1269 syms
[csym
] = syms
[cdebug
];
1278 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1279 newsymname
, symname
);
1281 syms
[csym
] = (struct symbol
*) msymbol
;
1287 /* Found a non-debuggable method symbol. */
1289 syms
[csym
] = (struct symbol
*) msymbol
;
1293 if (objc_csym
== NULL
)
1295 objc_csym
= obstack_alloc (&objfile
->objfile_obstack
,
1296 sizeof (*objc_csym
));
1297 *objc_csym
= objfile_csym
;
1298 set_objfile_data (objfile
, objc_objfile_data
, objc_csym
);
1301 /* Count of ObjC methods in this objfile should be constant. */
1302 gdb_assert (*objc_csym
== objfile_csym
);
1311 char *find_imps (struct symtab
*symtab
, struct block
*block
,
1312 char *method
, struct symbol
**syms
,
1313 unsigned int *nsym
, unsigned int *ndebug
)
1317 char *category
= NULL
;
1318 char *selector
= NULL
;
1320 unsigned int csym
= 0;
1321 unsigned int cdebug
= 0;
1323 unsigned int ncsym
= 0;
1324 unsigned int ncdebug
= 0;
1329 gdb_assert (nsym
!= NULL
);
1330 gdb_assert (ndebug
!= NULL
);
1337 buf
= (char *) alloca (strlen (method
) + 1);
1338 strcpy (buf
, method
);
1339 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1343 struct symbol
*sym
= NULL
;
1344 struct minimal_symbol
*msym
= NULL
;
1346 strcpy (buf
, method
);
1347 tmp
= parse_selector (buf
, &selector
);
1352 sym
= lookup_symbol (selector
, block
, VAR_DOMAIN
, 0);
1362 msym
= lookup_minimal_symbol (selector
, 0, 0);
1367 syms
[csym
] = (struct symbol
*)msym
;
1373 find_methods (symtab
, type
, class, category
, selector
,
1374 syms
+ csym
, &ncsym
, &ncdebug
);
1376 find_methods (symtab
, type
, class, category
, selector
,
1377 NULL
, &ncsym
, &ncdebug
);
1379 /* If we didn't find any methods, just return. */
1380 if (ncsym
== 0 && ncdebug
== 0)
1383 /* Take debug symbols from the second batch of symbols and swap them
1384 * with debug symbols from the first batch. Repeat until either the
1385 * second section is out of debug symbols or the first section is
1386 * full of debug symbols. Either way we have all debug symbols
1387 * packed to the beginning of the buffer.
1392 while ((cdebug
< csym
) && (ncdebug
> 0))
1394 struct symbol
*s
= NULL
;
1395 /* First non-debugging symbol. */
1396 unsigned int i
= cdebug
;
1397 /* Last of second batch of debug symbols. */
1398 unsigned int j
= csym
+ ncdebug
- 1;
1404 /* We've moved a symbol from the second debug section to the
1420 return method
+ (tmp
- buf
);
1424 /* Sort debuggable symbols. */
1426 qsort (syms
, cdebug
, sizeof (struct minimal_symbol
*),
1429 /* Sort minimal_symbols. */
1430 if ((csym
- cdebug
) > 1)
1431 qsort (&syms
[cdebug
], csym
- cdebug
,
1432 sizeof (struct minimal_symbol
*), compare_classes
);
1434 /* Terminate the sym_arr list. */
1437 return method
+ (tmp
- buf
);
1441 print_object_command (char *args
, int from_tty
)
1443 struct value
*object
, *function
, *description
;
1444 CORE_ADDR string_addr
, object_addr
;
1448 if (!args
|| !*args
)
1450 "The 'print-object' command requires an argument (an Objective-C object)");
1453 struct expression
*expr
= parse_expression (args
);
1454 struct cleanup
*old_chain
=
1455 make_cleanup (free_current_contents
, &expr
);
1458 object
= evaluate_subexp (builtin_type (expr
->gdbarch
)->builtin_data_ptr
,
1459 expr
, &pc
, EVAL_NORMAL
);
1460 do_cleanups (old_chain
);
1463 /* Validate the address for sanity. */
1464 object_addr
= value_as_long (object
);
1465 read_memory (object_addr
, &c
, 1);
1467 function
= find_function_in_inferior ("_NSPrintForDebugger", NULL
);
1468 if (function
== NULL
)
1469 error (_("Unable to locate _NSPrintForDebugger in child process"));
1471 description
= call_function_by_hand (function
, 1, &object
);
1473 string_addr
= value_as_long (description
);
1474 if (string_addr
== 0)
1475 error (_("object returns null description"));
1477 read_memory (string_addr
+ i
++, &c
, 1);
1480 { /* Read and print characters up to EOS. */
1482 printf_filtered ("%c", c
);
1483 read_memory (string_addr
+ i
++, &c
, 1);
1486 printf_filtered(_("<object returns empty description>"));
1487 printf_filtered ("\n");
1490 /* The data structure 'methcalls' is used to detect method calls (thru
1491 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1492 * and ultimately find the method being called.
1495 struct objc_methcall
{
1497 /* Return instance method to be called. */
1498 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1499 /* Start of pc range corresponding to method invocation. */
1501 /* End of pc range corresponding to method invocation. */
1505 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1506 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1507 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1508 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1510 static struct objc_methcall methcalls
[] = {
1511 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1512 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1513 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1514 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1515 { "_objc_getClass", NULL
, 0, 0},
1516 { "_objc_getMetaClass", NULL
, 0, 0}
1519 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1521 /* The following function, "find_objc_msgsend", fills in the data
1522 * structure "objc_msgs" by finding the addresses of each of the
1523 * (currently four) functions that it holds (of which objc_msgSend is
1524 * the first). This must be called each time symbols are loaded, in
1525 * case the functions have moved for some reason.
1529 find_objc_msgsend (void)
1533 for (i
= 0; i
< nmethcalls
; i
++)
1535 struct minimal_symbol
*func
;
1537 /* Try both with and without underscore. */
1538 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1539 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_'))
1541 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1545 methcalls
[i
].begin
= 0;
1546 methcalls
[i
].end
= 0;
1550 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1552 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1553 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
1557 /* find_objc_msgcall (replaces pc_off_limits)
1559 * ALL that this function now does is to determine whether the input
1560 * address ("pc") is the address of one of the Objective-C message
1561 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1562 * if so, it returns the address of the method that will be called.
1564 * The old function "pc_off_limits" used to do a lot of other things
1565 * in addition, such as detecting shared library jump stubs and
1566 * returning the address of the shlib function that would be called.
1567 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1568 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1569 * dependent modules.
1572 struct objc_submethod_helper_data
{
1573 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1579 find_objc_msgcall_submethod_helper (void * arg
)
1581 struct objc_submethod_helper_data
*s
=
1582 (struct objc_submethod_helper_data
*) arg
;
1584 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1591 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1595 struct objc_submethod_helper_data s
;
1601 if (catch_errors (find_objc_msgcall_submethod_helper
,
1603 "Unable to determine target of "
1604 "Objective-C method call (ignoring):\n",
1605 RETURN_MASK_ALL
) == 0)
1612 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1616 find_objc_msgsend ();
1622 for (i
= 0; i
< nmethcalls
; i
++)
1623 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1625 if (methcalls
[i
].stop_at
!= NULL
)
1626 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1635 /* -Wmissing-prototypes */
1636 extern initialize_file_ftype _initialize_objc_language
;
1639 _initialize_objc_language (void)
1641 add_language (&objc_language_defn
);
1642 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1643 _("All Objective-C selectors, or those matching REGEXP."));
1644 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1645 _("All Objective-C classes, or those matching REGEXP."));
1646 add_com ("print-object", class_vars
, print_object_command
,
1647 _("Ask an Objective-C object to print itself."));
1648 add_com_alias ("po", "print-object", class_vars
, 1);
1652 read_objc_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1653 struct objc_method
*method
)
1655 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1657 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4, byte_order
);
1658 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1659 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1662 static unsigned long
1663 read_objc_methlist_nmethods (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1665 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1667 return read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1671 read_objc_methlist_method (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1672 unsigned long num
, struct objc_method
*method
)
1674 gdb_assert (num
< read_objc_methlist_nmethods (gdbarch
, addr
));
1675 read_objc_method (gdbarch
, addr
+ 8 + (12 * num
), method
);
1679 read_objc_object (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1680 struct objc_object
*object
)
1682 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1684 object
->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1688 read_objc_super (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1689 struct objc_super
*super
)
1691 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1693 super
->receiver
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1694 super
->class = read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1698 read_objc_class (struct gdbarch
*gdbarch
, CORE_ADDR addr
,
1699 struct objc_class
*class)
1701 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1703 class->isa
= read_memory_unsigned_integer (addr
, 4, byte_order
);
1704 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4, byte_order
);
1705 class->name
= read_memory_unsigned_integer (addr
+ 8, 4, byte_order
);
1706 class->version
= read_memory_unsigned_integer (addr
+ 12, 4, byte_order
);
1707 class->info
= read_memory_unsigned_integer (addr
+ 16, 4, byte_order
);
1708 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4,
1710 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4, byte_order
);
1711 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4, byte_order
);
1712 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4, byte_order
);
1713 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4, byte_order
);
1717 find_implementation_from_class (struct gdbarch
*gdbarch
,
1718 CORE_ADDR
class, CORE_ADDR sel
)
1720 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1721 CORE_ADDR subclass
= class;
1723 while (subclass
!= 0)
1726 struct objc_class class_str
;
1727 unsigned mlistnum
= 0;
1729 read_objc_class (gdbarch
, subclass
, &class_str
);
1734 unsigned long nmethods
;
1737 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1743 nmethods
= read_objc_methlist_nmethods (gdbarch
, mlist
);
1745 for (i
= 0; i
< nmethods
; i
++)
1747 struct objc_method meth_str
;
1749 read_objc_methlist_method (gdbarch
, mlist
, i
, &meth_str
);
1752 "checking method 0x%lx against selector 0x%lx\n",
1753 meth_str
.name
, sel
);
1756 if (meth_str
.name
== sel
)
1757 /* FIXME: hppa arch was doing a pointer dereference
1758 here. There needs to be a better way to do that. */
1759 return meth_str
.imp
;
1763 subclass
= class_str
.super_class
;
1770 find_implementation (struct gdbarch
*gdbarch
,
1771 CORE_ADDR object
, CORE_ADDR sel
)
1773 struct objc_object ostr
;
1777 read_objc_object (gdbarch
, object
, &ostr
);
1781 return find_implementation_from_class (gdbarch
, ostr
.isa
, sel
);
1785 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1787 struct frame_info
*frame
= get_current_frame ();
1788 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1789 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1795 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1796 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1798 res
= find_implementation (gdbarch
, object
, sel
);
1807 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1809 struct frame_info
*frame
= get_current_frame ();
1810 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1811 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1817 object
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1818 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1820 res
= find_implementation (gdbarch
, object
, sel
);
1829 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1831 struct frame_info
*frame
= get_current_frame ();
1832 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1833 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1835 struct objc_super sstr
;
1841 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 0, ptr_type
);
1842 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1844 read_objc_super (gdbarch
, super
, &sstr
);
1845 if (sstr
.class == 0)
1848 res
= find_implementation_from_class (gdbarch
, sstr
.class, sel
);
1857 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1859 struct frame_info
*frame
= get_current_frame ();
1860 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1861 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_func_ptr
;
1863 struct objc_super sstr
;
1869 super
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 1, ptr_type
);
1870 sel
= gdbarch_fetch_pointer_argument (gdbarch
, frame
, 2, ptr_type
);
1872 read_objc_super (gdbarch
, super
, &sstr
);
1873 if (sstr
.class == 0)
1876 res
= find_implementation_from_class (gdbarch
, sstr
.class, sel
);
1885 _initialize_objc_lang (void)
1887 objc_objfile_data
= register_objfile_data ();