1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright (C) 2002, 2003, 2004, 2005, 2007 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 /* Lookup a structure type named "struct NAME", visible in lexical
79 block BLOCK. If NOERR is nonzero, return zero if NAME is not
83 lookup_struct_typedef (char *name
, struct block
*block
, int noerr
)
87 sym
= lookup_symbol (name
, block
, STRUCT_DOMAIN
, 0,
88 (struct symtab
**) NULL
);
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 (char *classname
)
111 struct value
* function
, *classval
;
113 if (! target_has_execution
)
115 /* Can't call into inferior to lookup class. */
119 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
120 function
= find_function_in_inferior("objc_lookUpClass");
121 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
122 function
= find_function_in_inferior("objc_lookup_class");
125 complaint (&symfile_complaints
, _("no way to lookup Objective-C classes"));
129 classval
= value_string (classname
, strlen (classname
) + 1);
130 classval
= value_coerce_array (classval
);
131 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
136 lookup_child_selector (char *selname
)
138 struct value
* function
, *selstring
;
140 if (! target_has_execution
)
142 /* Can't call into inferior to lookup selector. */
146 if (lookup_minimal_symbol("sel_getUid", 0, 0))
147 function
= find_function_in_inferior("sel_getUid");
148 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
149 function
= find_function_in_inferior("sel_get_any_uid");
152 complaint (&symfile_complaints
, _("no way to lookup Objective-C selectors"));
156 selstring
= value_coerce_array (value_string (selname
,
157 strlen (selname
) + 1));
158 return value_as_long (call_function_by_hand (function
, 1, &selstring
));
162 value_nsstring (char *ptr
, int len
)
164 struct value
*stringValue
[3];
165 struct value
*function
, *nsstringValue
;
169 if (!target_has_execution
)
170 return 0; /* Can't call into inferior to create NSString. */
172 sym
= lookup_struct_typedef("NSString", 0, 1);
174 sym
= lookup_struct_typedef("NXString", 0, 1);
176 type
= lookup_pointer_type(builtin_type_void
);
178 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
180 stringValue
[2] = value_string(ptr
, len
);
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");
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");
191 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
193 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
195 function
= find_function_in_inferior("+[NSString stringWithCString:]");
196 stringValue
[0] = value_from_longest
197 (builtin_type_long
, lookup_objc_class ("NSString"));
198 stringValue
[1] = value_from_longest
199 (builtin_type_long
, lookup_child_selector ("stringWithCString:"));
200 nsstringValue
= call_function_by_hand(function
, 3, &stringValue
[0]);
203 error (_("NSString: internal error -- no way to create new NSString"));
205 deprecated_set_value_type (nsstringValue
, type
);
206 return nsstringValue
;
209 /* Objective-C name demangling. */
212 objc_demangle (const char *mangled
, int options
)
214 char *demangled
, *cp
;
216 if (mangled
[0] == '_' &&
217 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
220 cp
= demangled
= xmalloc(strlen(mangled
) + 2);
222 if (mangled
[1] == 'i')
223 *cp
++ = '-'; /* for instance method */
225 *cp
++ = '+'; /* for class method */
227 *cp
++ = '['; /* opening left brace */
228 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
230 while (*cp
&& *cp
== '_')
231 cp
++; /* skip any initial underbars in class name */
233 cp
= strchr(cp
, '_');
234 if (!cp
) /* find first non-initial underbar */
236 xfree(demangled
); /* not mangled name */
239 if (cp
[1] == '_') { /* easy case: no category name */
240 *cp
++ = ' '; /* replace two '_' with one ' ' */
241 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
244 *cp
++ = '('; /* less easy case: category name */
245 cp
= strchr(cp
, '_');
248 xfree(demangled
); /* not mangled name */
252 *cp
++ = ' '; /* overwriting 1st char of method name... */
253 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
256 while (*cp
&& *cp
== '_')
257 cp
++; /* skip any initial underbars in method name */
261 *cp
= ':'; /* replace remaining '_' with ':' */
263 *cp
++ = ']'; /* closing right brace */
264 *cp
++ = 0; /* string terminator */
268 return NULL
; /* Not an objc mangled name. */
271 /* Print the character C on STREAM as part of the contents of a
272 literal string whose delimiter is QUOTER. Note that that format
273 for printing characters and strings is language specific. */
276 objc_emit_char (int c
, struct ui_file
*stream
, int quoter
)
279 c
&= 0xFF; /* Avoid sign bit follies. */
281 if (PRINT_LITERAL_FORM (c
))
283 if (c
== '\\' || c
== quoter
)
285 fputs_filtered ("\\", stream
);
287 fprintf_filtered (stream
, "%c", c
);
294 fputs_filtered ("\\n", stream
);
297 fputs_filtered ("\\b", stream
);
300 fputs_filtered ("\\t", stream
);
303 fputs_filtered ("\\f", stream
);
306 fputs_filtered ("\\r", stream
);
309 fputs_filtered ("\\e", stream
);
312 fputs_filtered ("\\a", stream
);
315 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
322 objc_printchar (int c
, struct ui_file
*stream
)
324 fputs_filtered ("'", stream
);
325 objc_emit_char (c
, stream
, '\'');
326 fputs_filtered ("'", stream
);
329 /* Print the character string STRING, printing at most LENGTH
330 characters. Printing stops early if the number hits print_max;
331 repeat counts are printed as appropriate. Print ellipses at the
332 end if we had to stop before printing LENGTH characters, or if
336 objc_printstr (struct ui_file
*stream
, const gdb_byte
*string
,
337 unsigned int length
, int width
, int force_ellipses
)
340 unsigned int things_printed
= 0;
344 /* If the string was not truncated due to `set print elements', and
345 the last byte of it is a null, we don't print that, in
346 traditional C style. */
347 if ((!force_ellipses
) && length
> 0 && string
[length
-1] == '\0')
352 fputs_filtered ("\"\"", stream
);
356 for (i
= 0; i
< length
&& things_printed
< print_max
; ++i
)
358 /* Position of the character we are examining to see whether it
361 /* Number of repetitions we have detected so far. */
368 fputs_filtered (", ", stream
);
374 while (rep1
< length
&& string
[rep1
] == string
[i
])
380 if (reps
> repeat_count_threshold
)
385 fputs_filtered ("\\\", ", stream
);
387 fputs_filtered ("\", ", stream
);
390 objc_printchar (string
[i
], stream
);
391 fprintf_filtered (stream
, " <repeats %u times>", reps
);
393 things_printed
+= repeat_count_threshold
;
401 fputs_filtered ("\\\"", stream
);
403 fputs_filtered ("\"", stream
);
406 objc_emit_char (string
[i
], stream
, '"');
411 /* Terminate the quotes if necessary. */
415 fputs_filtered ("\\\"", stream
);
417 fputs_filtered ("\"", stream
);
420 if (force_ellipses
|| i
< length
)
421 fputs_filtered ("...", stream
);
424 /* Create a fundamental C type using default reasonable for the
427 Some object/debugging file formats (DWARF version 1, COFF, etc) do
428 not define fundamental types such as "int" or "double". Others
429 (stabs or DWARF version 2, etc) do define fundamental types. For
430 the formats which don't provide fundamental types, gdb can create
431 such types using this function.
433 FIXME: Some compilers distinguish explicitly signed integral types
434 (signed short, signed int, signed long) from "regular" integral
435 types (short, int, long) in the debugging information. There is
436 some disagreement as to how useful this feature is. In particular,
437 gcc does not support this. Also, only some debugging formats allow
438 the distinction to be passed on to a debugger. For now, we always
439 just use "short", "int", or "long" as the type name, for both the
440 implicit and explicitly signed types. This also makes life easier
441 for the gdb test suite since we don't have to account for the
442 differences in output depending upon what the compiler and
443 debugging format support. We will probably have to re-examine the
444 issue when gdb starts taking it's fundamental type information
445 directly from the debugging information supplied by the compiler.
449 objc_create_fundamental_type (struct objfile
*objfile
, int typeid)
451 struct type
*type
= NULL
;
456 /* FIXME: For now, if we are asked to produce a type not in
457 this language, create the equivalent of a C integer type
458 with the name "<?type?>". When all the dust settles from
459 the type reconstruction work, this should probably become
461 type
= init_type (TYPE_CODE_INT
,
462 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
463 0, "<?type?>", objfile
);
464 warning (_("internal error: no C/C++ fundamental type %d"), typeid);
467 type
= init_type (TYPE_CODE_VOID
,
468 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
472 type
= init_type (TYPE_CODE_INT
,
473 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
477 type
= init_type (TYPE_CODE_INT
,
478 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
479 0, "signed char", objfile
);
481 case FT_UNSIGNED_CHAR
:
482 type
= init_type (TYPE_CODE_INT
,
483 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
484 TYPE_FLAG_UNSIGNED
, "unsigned char", objfile
);
487 type
= init_type (TYPE_CODE_INT
,
488 gdbarch_short_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
489 0, "short", objfile
);
491 case FT_SIGNED_SHORT
:
492 type
= init_type (TYPE_CODE_INT
,
493 gdbarch_short_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
494 0, "short", objfile
); /* FIXME-fnf */
496 case FT_UNSIGNED_SHORT
:
497 type
= init_type (TYPE_CODE_INT
,
498 gdbarch_short_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
499 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
502 type
= init_type (TYPE_CODE_INT
,
503 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
506 case FT_SIGNED_INTEGER
:
507 type
= init_type (TYPE_CODE_INT
,
508 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
509 0, "int", objfile
); /* FIXME -fnf */
511 case FT_UNSIGNED_INTEGER
:
512 type
= init_type (TYPE_CODE_INT
,
513 gdbarch_int_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
514 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
517 type
= init_type (TYPE_CODE_INT
,
518 gdbarch_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
522 type
= init_type (TYPE_CODE_INT
,
523 gdbarch_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
524 0, "long", objfile
); /* FIXME -fnf */
526 case FT_UNSIGNED_LONG
:
527 type
= init_type (TYPE_CODE_INT
,
528 gdbarch_long_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
529 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
532 type
= init_type (TYPE_CODE_INT
,
533 gdbarch_long_long_bit (current_gdbarch
)
535 0, "long long", objfile
);
537 case FT_SIGNED_LONG_LONG
:
538 type
= init_type (TYPE_CODE_INT
,
539 gdbarch_long_long_bit (current_gdbarch
)
541 0, "signed long long", objfile
);
543 case FT_UNSIGNED_LONG_LONG
:
544 type
= init_type (TYPE_CODE_INT
,
545 gdbarch_long_long_bit (current_gdbarch
)
547 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
550 type
= init_type (TYPE_CODE_FLT
,
551 gdbarch_float_bit (current_gdbarch
) / TARGET_CHAR_BIT
,
552 0, "float", objfile
);
554 case FT_DBL_PREC_FLOAT
:
555 type
= init_type (TYPE_CODE_FLT
,
556 gdbarch_double_bit (current_gdbarch
)
558 0, "double", objfile
);
560 case FT_EXT_PREC_FLOAT
:
561 type
= init_type (TYPE_CODE_FLT
,
562 gdbarch_long_double_bit (current_gdbarch
)
564 0, "long double", objfile
);
570 /* Determine if we are currently in the Objective-C dispatch function.
571 If so, get the address of the method function that the dispatcher
572 would call and use that as the function to step into instead. Also
573 skip over the trampoline for the function (if any). This is better
574 for the user since they are only interested in stepping into the
575 method function anyway. */
577 objc_skip_trampoline (struct frame_info
*frame
, CORE_ADDR stop_pc
)
579 CORE_ADDR real_stop_pc
;
580 CORE_ADDR method_stop_pc
;
582 real_stop_pc
= gdbarch_skip_trampoline_code
583 (current_gdbarch
, frame
, stop_pc
);
585 if (real_stop_pc
!= 0)
586 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
588 find_objc_msgcall (stop_pc
, &method_stop_pc
);
592 real_stop_pc
= gdbarch_skip_trampoline_code
593 (current_gdbarch
, frame
, method_stop_pc
);
594 if (real_stop_pc
== 0)
595 real_stop_pc
= method_stop_pc
;
602 /* Table mapping opcodes into strings for printing operators
603 and precedences of the operators. */
605 static const struct op_print objc_op_print_tab
[] =
607 {",", BINOP_COMMA
, PREC_COMMA
, 0},
608 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
609 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
610 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
611 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
612 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
613 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
614 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
615 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
616 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
617 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
618 {">", BINOP_GTR
, PREC_ORDER
, 0},
619 {"<", BINOP_LESS
, PREC_ORDER
, 0},
620 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
621 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
622 {"+", BINOP_ADD
, PREC_ADD
, 0},
623 {"-", BINOP_SUB
, PREC_ADD
, 0},
624 {"*", BINOP_MUL
, PREC_MUL
, 0},
625 {"/", BINOP_DIV
, PREC_MUL
, 0},
626 {"%", BINOP_REM
, PREC_MUL
, 0},
627 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
628 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
629 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
630 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
631 {"*", UNOP_IND
, PREC_PREFIX
, 0},
632 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
633 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
634 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
635 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
636 {NULL
, OP_NULL
, PREC_NULL
, 0}
639 const struct language_defn objc_language_defn
= {
640 "objective-c", /* Language name */
646 &exp_descriptor_standard
,
650 objc_printchar
, /* Print a character constant */
651 objc_printstr
, /* Function to print string constant */
653 objc_create_fundamental_type
, /* Create fundamental type in this language */
654 c_print_type
, /* Print a type using appropriate syntax */
655 c_val_print
, /* Print a value using appropriate syntax */
656 c_value_print
, /* Print a top-level value */
657 objc_skip_trampoline
, /* Language specific skip_trampoline */
658 value_of_this
, /* value_of_this */
659 basic_lookup_symbol_nonlocal
, /* lookup_symbol_nonlocal */
660 basic_lookup_transparent_type
,/* lookup_transparent_type */
661 objc_demangle
, /* Language specific symbol demangler */
662 NULL
, /* Language specific class_name_from_physname */
663 objc_op_print_tab
, /* Expression operators for printing */
664 1, /* C-style arrays */
665 0, /* String lower bound */
666 default_word_break_characters
,
667 c_language_arch_info
,
668 default_print_array_index
,
669 default_pass_by_reference
,
675 * Following functions help construct Objective-C message calls
678 struct selname
/* For parsing Objective-C. */
680 struct selname
*next
;
685 static int msglist_len
;
686 static struct selname
*selname_chain
;
687 static char *msglist_sel
;
692 struct selname
*new =
693 (struct selname
*) xmalloc (sizeof (struct selname
));
695 new->next
= selname_chain
;
696 new->msglist_len
= msglist_len
;
697 new->msglist_sel
= msglist_sel
;
699 msglist_sel
= (char *)xmalloc(1);
705 add_msglist(struct stoken
*str
, int addcolon
)
710 if (str
== 0) { /* Unnamed arg, or... */
711 if (addcolon
== 0) { /* variable number of args. */
721 len
= plen
+ strlen(msglist_sel
) + 2;
722 s
= (char *)xmalloc(len
);
723 strcpy(s
, msglist_sel
);
738 int val
= msglist_len
;
739 struct selname
*sel
= selname_chain
;
740 char *p
= msglist_sel
;
743 selname_chain
= sel
->next
;
744 msglist_len
= sel
->msglist_len
;
745 msglist_sel
= sel
->msglist_sel
;
746 selid
= lookup_child_selector(p
);
748 error (_("Can't find selector \"%s\""), p
);
749 write_exp_elt_longcst (selid
);
751 write_exp_elt_longcst (val
); /* Number of args */
758 * Function: specialcmp (char *a, char *b)
760 * Special strcmp: treats ']' and ' ' as end-of-string.
761 * Used for qsorting lists of objc methods (either by class or selector).
765 specialcmp (char *a
, char *b
)
767 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
773 if (*a
&& *a
!= ' ' && *a
!= ']')
774 return 1; /* a is longer therefore greater */
775 if (*b
&& *b
!= ' ' && *b
!= ']')
776 return -1; /* a is shorter therefore lesser */
777 return 0; /* a and b are identical */
781 * Function: compare_selectors (const void *, const void *)
783 * Comparison function for use with qsort. Arguments are symbols or
784 * msymbols Compares selector part of objc method name alphabetically.
788 compare_selectors (const void *a
, const void *b
)
792 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
793 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
794 if (aname
== NULL
|| bname
== NULL
)
795 error (_("internal: compare_selectors(1)"));
797 aname
= strchr(aname
, ' ');
798 bname
= strchr(bname
, ' ');
799 if (aname
== NULL
|| bname
== NULL
)
800 error (_("internal: compare_selectors(2)"));
802 return specialcmp (aname
+1, bname
+1);
806 * Function: selectors_info (regexp, from_tty)
808 * Implements the "Info selectors" command. Takes an optional regexp
809 * arg. Lists all objective c selectors that match the regexp. Works
810 * by grepping thru all symbols for objective c methods. Output list
811 * is sorted and uniqued.
815 selectors_info (char *regexp
, int from_tty
)
817 struct objfile
*objfile
;
818 struct minimal_symbol
*msymbol
;
826 struct symbol
**sym_arr
;
830 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
833 if (*regexp
== '+' || *regexp
== '-')
834 { /* User wants only class methods or only instance methods. */
835 plusminus
= *regexp
++;
836 while (*regexp
== ' ' || *regexp
== '\t')
840 strcpy(myregexp
, ".*]");
843 strcpy(myregexp
, regexp
);
844 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
845 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
847 strcat(myregexp
, ".*]");
853 val
= re_comp (myregexp
);
855 error (_("Invalid regexp (%s): %s"), val
, regexp
);
858 /* First time thru is JUST to get max length and count. */
859 ALL_MSYMBOLS (objfile
, msymbol
)
862 name
= SYMBOL_NATURAL_NAME (msymbol
);
864 (name
[0] == '-' || name
[0] == '+') &&
865 name
[1] == '[') /* Got a method name. */
867 /* Filter for class/instance methods. */
868 if (plusminus
&& name
[0] != plusminus
)
870 /* Find selector part. */
871 name
= (char *) strchr(name
+2, ' ');
872 if (regexp
== NULL
|| re_exec(++name
) != 0)
874 char *mystart
= name
;
875 char *myend
= (char *) strchr(mystart
, ']');
877 if (myend
&& (myend
- mystart
> maxlen
))
878 maxlen
= myend
- mystart
; /* Get longest selector. */
885 printf_filtered (_("Selectors matching \"%s\":\n\n"),
886 regexp
? regexp
: "*");
888 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
890 ALL_MSYMBOLS (objfile
, msymbol
)
893 name
= SYMBOL_NATURAL_NAME (msymbol
);
895 (name
[0] == '-' || name
[0] == '+') &&
896 name
[1] == '[') /* Got a method name. */
898 /* Filter for class/instance methods. */
899 if (plusminus
&& name
[0] != plusminus
)
901 /* Find selector part. */
902 name
= (char *) strchr(name
+2, ' ');
903 if (regexp
== NULL
|| re_exec(++name
) != 0)
904 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
908 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
910 /* Prevent compare on first iteration. */
912 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
917 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
918 name
= strchr (name
, ' ') + 1;
919 if (p
[0] && specialcmp(name
, p
) == 0)
920 continue; /* Seen this one already (not unique). */
922 /* Copy selector part. */
923 while (*name
&& *name
!= ']')
926 /* Print in columns. */
927 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
932 printf_filtered (_("No selectors matching \"%s\"\n"), regexp
? regexp
: "*");
936 * Function: compare_classes (const void *, const void *)
938 * Comparison function for use with qsort. Arguments are symbols or
939 * msymbols Compares class part of objc method name alphabetically.
943 compare_classes (const void *a
, const void *b
)
947 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
948 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
949 if (aname
== NULL
|| bname
== NULL
)
950 error (_("internal: compare_classes(1)"));
952 return specialcmp (aname
+1, bname
+1);
956 * Function: classes_info(regexp, from_tty)
958 * Implements the "info classes" command for objective c classes.
959 * Lists all objective c classes that match the optional regexp.
960 * Works by grepping thru the list of objective c methods. List will
961 * be sorted and uniqued (since one class may have many methods).
962 * BUGS: will not list a class that has no methods.
966 classes_info (char *regexp
, int from_tty
)
968 struct objfile
*objfile
;
969 struct minimal_symbol
*msymbol
;
977 struct symbol
**sym_arr
;
980 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
983 strcpy(myregexp
, regexp
);
984 if (myregexp
[strlen(myregexp
) - 1] == '$')
985 /* In the method name, the end of the class name is marked by ' '. */
986 myregexp
[strlen(myregexp
) - 1] = ' ';
988 strcat(myregexp
, ".* ");
993 val
= re_comp (myregexp
);
995 error (_("Invalid regexp (%s): %s"), val
, regexp
);
998 /* First time thru is JUST to get max length and count. */
999 ALL_MSYMBOLS (objfile
, msymbol
)
1002 name
= SYMBOL_NATURAL_NAME (msymbol
);
1004 (name
[0] == '-' || name
[0] == '+') &&
1005 name
[1] == '[') /* Got a method name. */
1006 if (regexp
== NULL
|| re_exec(name
+2) != 0)
1008 /* Compute length of classname part. */
1009 char *mystart
= name
+ 2;
1010 char *myend
= (char *) strchr(mystart
, ' ');
1012 if (myend
&& (myend
- mystart
> maxlen
))
1013 maxlen
= myend
- mystart
;
1019 printf_filtered (_("Classes matching \"%s\":\n\n"),
1020 regexp
? regexp
: "*");
1021 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
1023 ALL_MSYMBOLS (objfile
, msymbol
)
1026 name
= SYMBOL_NATURAL_NAME (msymbol
);
1028 (name
[0] == '-' || name
[0] == '+') &&
1029 name
[1] == '[') /* Got a method name. */
1030 if (regexp
== NULL
|| re_exec(name
+2) != 0)
1031 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
1034 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
1036 /* Prevent compare on first iteration. */
1038 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
1043 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
1045 if (p
[0] && specialcmp(name
, p
) == 0)
1046 continue; /* Seen this one already (not unique). */
1048 /* Copy class part of method name. */
1049 while (*name
&& *name
!= ' ')
1052 /* Print in columns. */
1053 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
1058 printf_filtered (_("No classes matching \"%s\"\n"), regexp
? regexp
: "*");
1062 * Function: find_imps (char *selector, struct symbol **sym_arr)
1064 * Input: a string representing a selector
1065 * a pointer to an array of symbol pointers
1066 * possibly a pointer to a symbol found by the caller.
1068 * Output: number of methods that implement that selector. Side
1069 * effects: The array of symbol pointers is filled with matching syms.
1071 * By analogy with function "find_methods" (symtab.c), builds a list
1072 * of symbols matching the ambiguous input, so that "decode_line_2"
1073 * (symtab.c) can list them and ask the user to choose one or more.
1074 * In this case the matches are objective c methods
1075 * ("implementations") matching an objective c selector.
1077 * Note that it is possible for a normal (c-style) function to have
1078 * the same name as an objective c selector. To prevent the selector
1079 * from eclipsing the function, we allow the caller (decode_line_1) to
1080 * search for such a function first, and if it finds one, pass it in
1081 * to us. We will then integrate it into the list. We also search
1082 * for one here, among the minsyms.
1084 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1085 * into two parts: debuggable (struct symbol) syms, and
1086 * non_debuggable (struct minimal_symbol) syms. The debuggable
1087 * ones will come first, before NUM_DEBUGGABLE (which will thus
1088 * be the index of the first non-debuggable one).
1092 * Function: total_number_of_imps (char *selector);
1094 * Input: a string representing a selector
1095 * Output: number of methods that implement that selector.
1097 * By analogy with function "total_number_of_methods", this allows
1098 * decode_line_1 (symtab.c) to detect if there are objective c methods
1099 * matching the input, and to allocate an array of pointers to them
1100 * which can be manipulated by "decode_line_2" (also in symtab.c).
1104 parse_selector (char *method
, char **selector
)
1108 int found_quote
= 0;
1110 char *nselector
= NULL
;
1112 gdb_assert (selector
!= NULL
);
1116 while (isspace (*s1
))
1123 while (isspace (*s1
))
1130 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1132 else if (isspace (*s2
))
1134 else if ((*s2
== '\0') || (*s2
== '\''))
1142 while (isspace (*s2
))
1148 while (isspace (*s2
))
1152 if (selector
!= NULL
)
1153 *selector
= nselector
;
1159 parse_method (char *method
, char *type
, char **class,
1160 char **category
, char **selector
)
1164 int found_quote
= 0;
1167 char *nclass
= NULL
;
1168 char *ncategory
= NULL
;
1169 char *nselector
= NULL
;
1171 gdb_assert (type
!= NULL
);
1172 gdb_assert (class != NULL
);
1173 gdb_assert (category
!= NULL
);
1174 gdb_assert (selector
!= NULL
);
1178 while (isspace (*s1
))
1185 while (isspace (*s1
))
1188 if ((s1
[0] == '+') || (s1
[0] == '-'))
1191 while (isspace (*s1
))
1199 while (isalnum (*s1
) || (*s1
== '_'))
1203 while (isspace (*s2
))
1209 while (isspace (*s2
))
1212 while (isalnum (*s2
) || (*s2
== '_'))
1217 /* Truncate the class name now that we're not using the open paren. */
1224 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1226 else if (isspace (*s2
))
1228 else if (*s2
== ']')
1237 while (isspace (*s2
))
1244 while (isspace (*s2
))
1252 if (category
!= NULL
)
1253 *category
= ncategory
;
1254 if (selector
!= NULL
)
1255 *selector
= nselector
;
1261 find_methods (struct symtab
*symtab
, char type
,
1262 const char *class, const char *category
,
1263 const char *selector
, struct symbol
**syms
,
1264 unsigned int *nsym
, unsigned int *ndebug
)
1266 struct objfile
*objfile
= NULL
;
1267 struct minimal_symbol
*msymbol
= NULL
;
1268 struct block
*block
= NULL
;
1269 struct symbol
*sym
= NULL
;
1271 char *symname
= NULL
;
1274 char *nclass
= NULL
;
1275 char *ncategory
= NULL
;
1276 char *nselector
= NULL
;
1278 unsigned int csym
= 0;
1279 unsigned int cdebug
= 0;
1281 static char *tmp
= NULL
;
1282 static unsigned int tmplen
= 0;
1284 gdb_assert (nsym
!= NULL
);
1285 gdb_assert (ndebug
!= NULL
);
1288 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1290 ALL_MSYMBOLS (objfile
, msymbol
)
1294 if ((msymbol
->type
!= mst_text
) && (msymbol
->type
!= mst_file_text
))
1295 /* Not a function or method. */
1299 if ((SYMBOL_VALUE_ADDRESS (msymbol
) < BLOCK_START (block
)) ||
1300 (SYMBOL_VALUE_ADDRESS (msymbol
) >= BLOCK_END (block
)))
1301 /* Not in the specified symtab. */
1304 symname
= SYMBOL_NATURAL_NAME (msymbol
);
1305 if (symname
== NULL
)
1308 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1309 /* Not a method name. */
1312 while ((strlen (symname
) + 1) >= tmplen
)
1314 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1315 tmp
= xrealloc (tmp
, tmplen
);
1317 strcpy (tmp
, symname
);
1319 if (parse_method (tmp
, &ntype
, &nclass
, &ncategory
, &nselector
) == NULL
)
1322 if ((type
!= '\0') && (ntype
!= type
))
1326 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1329 if ((category
!= NULL
) &&
1330 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1333 if ((selector
!= NULL
) &&
1334 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1337 sym
= find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol
));
1340 const char *newsymname
= SYMBOL_NATURAL_NAME (sym
);
1342 if (strcmp (symname
, newsymname
) == 0)
1344 /* Found a high-level method sym: swap it into the
1345 lower part of sym_arr (below num_debuggable). */
1348 syms
[csym
] = syms
[cdebug
];
1357 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1358 newsymname
, symname
);
1360 syms
[csym
] = (struct symbol
*) msymbol
;
1366 /* Found a non-debuggable method symbol. */
1368 syms
[csym
] = (struct symbol
*) msymbol
;
1379 char *find_imps (struct symtab
*symtab
, struct block
*block
,
1380 char *method
, struct symbol
**syms
,
1381 unsigned int *nsym
, unsigned int *ndebug
)
1385 char *category
= NULL
;
1386 char *selector
= NULL
;
1388 unsigned int csym
= 0;
1389 unsigned int cdebug
= 0;
1391 unsigned int ncsym
= 0;
1392 unsigned int ncdebug
= 0;
1397 gdb_assert (nsym
!= NULL
);
1398 gdb_assert (ndebug
!= NULL
);
1405 buf
= (char *) alloca (strlen (method
) + 1);
1406 strcpy (buf
, method
);
1407 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1411 struct symbol
*sym
= NULL
;
1412 struct minimal_symbol
*msym
= NULL
;
1414 strcpy (buf
, method
);
1415 tmp
= parse_selector (buf
, &selector
);
1420 sym
= lookup_symbol (selector
, block
, VAR_DOMAIN
, 0, NULL
);
1430 msym
= lookup_minimal_symbol (selector
, 0, 0);
1435 syms
[csym
] = (struct symbol
*)msym
;
1441 find_methods (symtab
, type
, class, category
, selector
,
1442 syms
+ csym
, &ncsym
, &ncdebug
);
1444 find_methods (symtab
, type
, class, category
, selector
,
1445 NULL
, &ncsym
, &ncdebug
);
1447 /* If we didn't find any methods, just return. */
1448 if (ncsym
== 0 && ncdebug
== 0)
1451 /* Take debug symbols from the second batch of symbols and swap them
1452 * with debug symbols from the first batch. Repeat until either the
1453 * second section is out of debug symbols or the first section is
1454 * full of debug symbols. Either way we have all debug symbols
1455 * packed to the beginning of the buffer.
1460 while ((cdebug
< csym
) && (ncdebug
> 0))
1462 struct symbol
*s
= NULL
;
1463 /* First non-debugging symbol. */
1464 unsigned int i
= cdebug
;
1465 /* Last of second batch of debug symbols. */
1466 unsigned int j
= csym
+ ncdebug
- 1;
1472 /* We've moved a symbol from the second debug section to the
1488 return method
+ (tmp
- buf
);
1492 /* Sort debuggable symbols. */
1494 qsort (syms
, cdebug
, sizeof (struct minimal_symbol
*),
1497 /* Sort minimal_symbols. */
1498 if ((csym
- cdebug
) > 1)
1499 qsort (&syms
[cdebug
], csym
- cdebug
,
1500 sizeof (struct minimal_symbol
*), compare_classes
);
1502 /* Terminate the sym_arr list. */
1505 return method
+ (tmp
- buf
);
1509 print_object_command (char *args
, int from_tty
)
1511 struct value
*object
, *function
, *description
;
1512 CORE_ADDR string_addr
, object_addr
;
1516 if (!args
|| !*args
)
1518 "The 'print-object' command requires an argument (an Objective-C object)");
1521 struct expression
*expr
= parse_expression (args
);
1522 struct cleanup
*old_chain
=
1523 make_cleanup (free_current_contents
, &expr
);
1526 object
= expr
->language_defn
->la_exp_desc
->evaluate_exp
1527 (builtin_type_void_data_ptr
, expr
, &pc
, EVAL_NORMAL
);
1528 do_cleanups (old_chain
);
1531 /* Validate the address for sanity. */
1532 object_addr
= value_as_long (object
);
1533 read_memory (object_addr
, &c
, 1);
1535 function
= find_function_in_inferior ("_NSPrintForDebugger");
1536 if (function
== NULL
)
1537 error (_("Unable to locate _NSPrintForDebugger in child process"));
1539 description
= call_function_by_hand (function
, 1, &object
);
1541 string_addr
= value_as_long (description
);
1542 if (string_addr
== 0)
1543 error (_("object returns null description"));
1545 read_memory (string_addr
+ i
++, &c
, 1);
1548 { /* Read and print characters up to EOS. */
1550 printf_filtered ("%c", c
);
1551 read_memory (string_addr
+ i
++, &c
, 1);
1554 printf_filtered(_("<object returns empty description>"));
1555 printf_filtered ("\n");
1558 /* The data structure 'methcalls' is used to detect method calls (thru
1559 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1560 * and ultimately find the method being called.
1563 struct objc_methcall
{
1565 /* Return instance method to be called. */
1566 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1567 /* Start of pc range corresponding to method invocation. */
1569 /* End of pc range corresponding to method invocation. */
1573 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1574 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1575 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1576 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1578 static struct objc_methcall methcalls
[] = {
1579 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1580 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1581 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1582 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1583 { "_objc_getClass", NULL
, 0, 0},
1584 { "_objc_getMetaClass", NULL
, 0, 0}
1587 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1589 /* The following function, "find_objc_msgsend", fills in the data
1590 * structure "objc_msgs" by finding the addresses of each of the
1591 * (currently four) functions that it holds (of which objc_msgSend is
1592 * the first). This must be called each time symbols are loaded, in
1593 * case the functions have moved for some reason.
1597 find_objc_msgsend (void)
1600 for (i
= 0; i
< nmethcalls
; i
++) {
1602 struct minimal_symbol
*func
;
1604 /* Try both with and without underscore. */
1605 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1606 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_')) {
1607 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1610 methcalls
[i
].begin
= 0;
1611 methcalls
[i
].end
= 0;
1615 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1617 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1618 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
1622 /* find_objc_msgcall (replaces pc_off_limits)
1624 * ALL that this function now does is to determine whether the input
1625 * address ("pc") is the address of one of the Objective-C message
1626 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1627 * if so, it returns the address of the method that will be called.
1629 * The old function "pc_off_limits" used to do a lot of other things
1630 * in addition, such as detecting shared library jump stubs and
1631 * returning the address of the shlib function that would be called.
1632 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1633 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1634 * dependent modules.
1637 struct objc_submethod_helper_data
{
1638 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1644 find_objc_msgcall_submethod_helper (void * arg
)
1646 struct objc_submethod_helper_data
*s
=
1647 (struct objc_submethod_helper_data
*) arg
;
1649 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1656 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1660 struct objc_submethod_helper_data s
;
1666 if (catch_errors (find_objc_msgcall_submethod_helper
,
1668 "Unable to determine target of Objective-C method call (ignoring):\n",
1669 RETURN_MASK_ALL
) == 0)
1676 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1680 find_objc_msgsend ();
1686 for (i
= 0; i
< nmethcalls
; i
++)
1687 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1689 if (methcalls
[i
].stop_at
!= NULL
)
1690 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1699 extern initialize_file_ftype _initialize_objc_language
; /* -Wmissing-prototypes */
1702 _initialize_objc_language (void)
1704 add_language (&objc_language_defn
);
1705 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1706 _("All Objective-C selectors, or those matching REGEXP."));
1707 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1708 _("All Objective-C classes, or those matching REGEXP."));
1709 add_com ("print-object", class_vars
, print_object_command
,
1710 _("Ask an Objective-C object to print itself."));
1711 add_com_alias ("po", "print-object", class_vars
, 1);
1715 read_objc_method (CORE_ADDR addr
, struct objc_method
*method
)
1717 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4);
1718 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4);
1719 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4);
1723 unsigned long read_objc_methlist_nmethods (CORE_ADDR addr
)
1725 return read_memory_unsigned_integer (addr
+ 4, 4);
1729 read_objc_methlist_method (CORE_ADDR addr
, unsigned long num
,
1730 struct objc_method
*method
)
1732 gdb_assert (num
< read_objc_methlist_nmethods (addr
));
1733 read_objc_method (addr
+ 8 + (12 * num
), method
);
1737 read_objc_object (CORE_ADDR addr
, struct objc_object
*object
)
1739 object
->isa
= read_memory_unsigned_integer (addr
, 4);
1743 read_objc_super (CORE_ADDR addr
, struct objc_super
*super
)
1745 super
->receiver
= read_memory_unsigned_integer (addr
, 4);
1746 super
->class = read_memory_unsigned_integer (addr
+ 4, 4);
1750 read_objc_class (CORE_ADDR addr
, struct objc_class
*class)
1752 class->isa
= read_memory_unsigned_integer (addr
, 4);
1753 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4);
1754 class->name
= read_memory_unsigned_integer (addr
+ 8, 4);
1755 class->version
= read_memory_unsigned_integer (addr
+ 12, 4);
1756 class->info
= read_memory_unsigned_integer (addr
+ 16, 4);
1757 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4);
1758 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4);
1759 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4);
1760 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4);
1761 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4);
1765 find_implementation_from_class (CORE_ADDR
class, CORE_ADDR sel
)
1767 CORE_ADDR subclass
= class;
1769 while (subclass
!= 0)
1772 struct objc_class class_str
;
1773 unsigned mlistnum
= 0;
1775 read_objc_class (subclass
, &class_str
);
1780 unsigned long nmethods
;
1783 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1788 nmethods
= read_objc_methlist_nmethods (mlist
);
1790 for (i
= 0; i
< nmethods
; i
++)
1792 struct objc_method meth_str
;
1793 read_objc_methlist_method (mlist
, i
, &meth_str
);
1797 "checking method 0x%lx against selector 0x%lx\n",
1798 meth_str
.name
, sel
);
1801 if (meth_str
.name
== sel
)
1802 /* FIXME: hppa arch was doing a pointer dereference
1803 here. There needs to be a better way to do that. */
1804 return meth_str
.imp
;
1808 subclass
= class_str
.super_class
;
1815 find_implementation (CORE_ADDR object
, CORE_ADDR sel
)
1817 struct objc_object ostr
;
1821 read_objc_object (object
, &ostr
);
1825 return find_implementation_from_class (ostr
.isa
, sel
);
1828 #define OBJC_FETCH_POINTER_ARGUMENT(argi) \
1829 gdbarch_fetch_pointer_argument (current_gdbarch, get_current_frame (), \
1830 argi, builtin_type_void_func_ptr)
1833 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1839 object
= OBJC_FETCH_POINTER_ARGUMENT (0);
1840 sel
= OBJC_FETCH_POINTER_ARGUMENT (1);
1842 res
= find_implementation (object
, sel
);
1851 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1857 object
= OBJC_FETCH_POINTER_ARGUMENT (1);
1858 sel
= OBJC_FETCH_POINTER_ARGUMENT (2);
1860 res
= find_implementation (object
, sel
);
1869 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1871 struct objc_super sstr
;
1877 super
= OBJC_FETCH_POINTER_ARGUMENT (0);
1878 sel
= OBJC_FETCH_POINTER_ARGUMENT (1);
1880 read_objc_super (super
, &sstr
);
1881 if (sstr
.class == 0)
1884 res
= find_implementation_from_class (sstr
.class, sel
);
1893 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1895 struct objc_super sstr
;
1901 super
= OBJC_FETCH_POINTER_ARGUMENT (1);
1902 sel
= OBJC_FETCH_POINTER_ARGUMENT (2);
1904 read_objc_super (super
, &sstr
);
1905 if (sstr
.class == 0)
1908 res
= find_implementation_from_class (sstr
.class, sel
);