1 /* Objective-C language support routines for GDB, the GNU debugger.
3 Copyright 2002, 2003 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 2 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, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
28 #include "expression.h"
29 #include "parser-defs.h"
32 #include "objc-lang.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"
55 CORE_ADDR super_class
;
77 /* Complaints about ObjC classes, selectors, etc. */
79 #if (!defined __GNUC__ || __GNUC__ < 2 || __GNUC_MINOR__ < (defined __cplusplus ? 6 : 4))
80 #define __CHECK_FUNCTION ((__const char *) 0)
82 #define __CHECK_FUNCTION __PRETTY_FUNCTION__
85 #define CHECK(expression) \
86 ((void) ((expression) ? 0 : gdb_check (#expression, __FILE__, __LINE__, \
89 #define CHECK_FATAL(expression) \
90 ((void) ((expression) ? 0 : gdb_check_fatal (#expression, __FILE__, \
91 __LINE__, __CHECK_FUNCTION)))
94 gdb_check (const char *str
, const char *file
,
95 unsigned int line
, const char *func
)
97 error ("assertion failure on line %u of \"%s\" in function \"%s\": %s\n",
98 line
, file
, func
, str
);
102 gdb_check_fatal (const char *str
, const char *file
,
103 unsigned int line
, const char *func
)
105 internal_error (file
, line
,
106 "assertion failure in function \"%s\": %s\n", func
, str
);
109 /* Lookup a structure type named "struct NAME", visible in lexical
110 block BLOCK. If NOERR is nonzero, return zero if NAME is not
114 lookup_struct_typedef (char *name
, struct block
*block
, int noerr
)
116 register struct symbol
*sym
;
118 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
119 (struct symtab
**) NULL
);
126 error ("No struct type named %s.", name
);
128 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
133 error ("This context has class, union or enum %s, not a struct.",
140 lookup_objc_class (char *classname
)
142 struct value
* function
, *classval
;
144 if (! target_has_execution
)
146 /* Can't call into inferior to lookup class. */
150 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
151 function
= find_function_in_inferior("objc_lookUpClass");
152 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
153 function
= find_function_in_inferior("objc_lookup_class");
156 complaint (&symfile_complaints
, "no way to lookup Objective-C classes");
160 classval
= value_string (classname
, strlen (classname
) + 1);
161 classval
= value_coerce_array (classval
);
162 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
167 lookup_child_selector (char *selname
)
169 struct value
* function
, *selstring
;
171 if (! target_has_execution
)
173 /* Can't call into inferior to lookup selector. */
177 if (lookup_minimal_symbol("sel_getUid", 0, 0))
178 function
= find_function_in_inferior("sel_getUid");
179 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
180 function
= find_function_in_inferior("sel_get_any_uid");
183 complaint (&symfile_complaints
, "no way to lookup Objective-C selectors");
187 selstring
= value_coerce_array (value_string (selname
,
188 strlen (selname
) + 1));
189 return value_as_long (call_function_by_hand (function
, 1, &selstring
));
193 value_nsstring (char *ptr
, int len
)
195 struct value
*stringValue
[3];
196 struct value
*function
, *nsstringValue
;
200 if (!target_has_execution
)
201 return 0; /* Can't call into inferior to create NSString. */
203 sym
= lookup_struct_typedef("NSString", 0, 1);
205 sym
= lookup_struct_typedef("NXString", 0, 1);
207 type
= lookup_pointer_type(builtin_type_void
);
209 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
211 stringValue
[2] = value_string(ptr
, len
);
212 stringValue
[2] = value_coerce_array(stringValue
[2]);
213 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
214 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
216 function
= find_function_in_inferior("_NSNewStringFromCString");
217 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
219 else if (lookup_minimal_symbol("istr", 0, 0))
221 function
= find_function_in_inferior("istr");
222 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
224 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
226 function
= find_function_in_inferior("+[NSString stringWithCString:]");
227 stringValue
[0] = value_from_longest
228 (builtin_type_long
, lookup_objc_class ("NSString"));
229 stringValue
[1] = value_from_longest
230 (builtin_type_long
, lookup_child_selector ("stringWithCString:"));
231 nsstringValue
= call_function_by_hand(function
, 3, &stringValue
[0]);
234 error ("NSString: internal error -- no way to create new NSString");
236 VALUE_TYPE(nsstringValue
) = type
;
237 return nsstringValue
;
240 /* Objective-C name demangling. */
243 objc_demangle (const char *mangled
, int options
)
245 char *demangled
, *cp
;
247 if (mangled
[0] == '_' &&
248 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
251 cp
= demangled
= xmalloc(strlen(mangled
) + 2);
253 if (mangled
[1] == 'i')
254 *cp
++ = '-'; /* for instance method */
256 *cp
++ = '+'; /* for class method */
258 *cp
++ = '['; /* opening left brace */
259 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
261 while (*cp
&& *cp
== '_')
262 cp
++; /* skip any initial underbars in class name */
264 cp
= strchr(cp
, '_');
265 if (!cp
) /* find first non-initial underbar */
267 xfree(demangled
); /* not mangled name */
270 if (cp
[1] == '_') { /* easy case: no category name */
271 *cp
++ = ' '; /* replace two '_' with one ' ' */
272 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
275 *cp
++ = '('; /* less easy case: category name */
276 cp
= strchr(cp
, '_');
279 xfree(demangled
); /* not mangled name */
283 *cp
++ = ' '; /* overwriting 1st char of method name... */
284 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
287 while (*cp
&& *cp
== '_')
288 cp
++; /* skip any initial underbars in method name */
292 *cp
= ':'; /* replace remaining '_' with ':' */
294 *cp
++ = ']'; /* closing right brace */
295 *cp
++ = 0; /* string terminator */
299 return NULL
; /* Not an objc mangled name. */
302 /* Print the character C on STREAM as part of the contents of a
303 literal string whose delimiter is QUOTER. Note that that format
304 for printing characters and strings is language specific. */
307 objc_emit_char (register int c
, struct ui_file
*stream
, int quoter
)
310 c
&= 0xFF; /* Avoid sign bit follies. */
312 if (PRINT_LITERAL_FORM (c
))
314 if (c
== '\\' || c
== quoter
)
316 fputs_filtered ("\\", stream
);
318 fprintf_filtered (stream
, "%c", c
);
325 fputs_filtered ("\\n", stream
);
328 fputs_filtered ("\\b", stream
);
331 fputs_filtered ("\\t", stream
);
334 fputs_filtered ("\\f", stream
);
337 fputs_filtered ("\\r", stream
);
340 fputs_filtered ("\\e", stream
);
343 fputs_filtered ("\\a", stream
);
346 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
353 objc_printchar (int c
, struct ui_file
*stream
)
355 fputs_filtered ("'", stream
);
356 objc_emit_char (c
, stream
, '\'');
357 fputs_filtered ("'", stream
);
360 /* Print the character string STRING, printing at most LENGTH
361 characters. Printing stops early if the number hits print_max;
362 repeat counts are printed as appropriate. Print ellipses at the
363 end if we had to stop before printing LENGTH characters, or if
367 objc_printstr (struct ui_file
*stream
, char *string
,
368 unsigned int length
, int width
, int force_ellipses
)
370 register unsigned int i
;
371 unsigned int things_printed
= 0;
374 extern int inspect_it
;
376 /* If the string was not truncated due to `set print elements', and
377 the last byte of it is a null, we don't print that, in
378 traditional C style. */
379 if ((!force_ellipses
) && length
> 0 && string
[length
-1] == '\0')
384 fputs_filtered ("\"\"", stream
);
388 for (i
= 0; i
< length
&& things_printed
< print_max
; ++i
)
390 /* Position of the character we are examining to see whether it
393 /* Number of repetitions we have detected so far. */
400 fputs_filtered (", ", stream
);
406 while (rep1
< length
&& string
[rep1
] == string
[i
])
412 if (reps
> repeat_count_threshold
)
417 fputs_filtered ("\\\", ", stream
);
419 fputs_filtered ("\", ", stream
);
422 objc_printchar (string
[i
], stream
);
423 fprintf_filtered (stream
, " <repeats %u times>", reps
);
425 things_printed
+= repeat_count_threshold
;
433 fputs_filtered ("\\\"", stream
);
435 fputs_filtered ("\"", stream
);
438 objc_emit_char (string
[i
], stream
, '"');
443 /* Terminate the quotes if necessary. */
447 fputs_filtered ("\\\"", stream
);
449 fputs_filtered ("\"", stream
);
452 if (force_ellipses
|| i
< length
)
453 fputs_filtered ("...", stream
);
456 /* Create a fundamental C type using default reasonable for the
459 Some object/debugging file formats (DWARF version 1, COFF, etc) do
460 not define fundamental types such as "int" or "double". Others
461 (stabs or DWARF version 2, etc) do define fundamental types. For
462 the formats which don't provide fundamental types, gdb can create
463 such types using this function.
465 FIXME: Some compilers distinguish explicitly signed integral types
466 (signed short, signed int, signed long) from "regular" integral
467 types (short, int, long) in the debugging information. There is
468 some disagreement as to how useful this feature is. In particular,
469 gcc does not support this. Also, only some debugging formats allow
470 the distinction to be passed on to a debugger. For now, we always
471 just use "short", "int", or "long" as the type name, for both the
472 implicit and explicitly signed types. This also makes life easier
473 for the gdb test suite since we don't have to account for the
474 differences in output depending upon what the compiler and
475 debugging format support. We will probably have to re-examine the
476 issue when gdb starts taking it's fundamental type information
477 directly from the debugging information supplied by the compiler.
481 objc_create_fundamental_type (struct objfile
*objfile
, int typeid)
483 register struct type
*type
= NULL
;
488 /* FIXME: For now, if we are asked to produce a type not in
489 this language, create the equivalent of a C integer type
490 with the name "<?type?>". When all the dust settles from
491 the type reconstruction work, this should probably become
493 type
= init_type (TYPE_CODE_INT
,
494 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
495 0, "<?type?>", objfile
);
496 warning ("internal error: no C/C++ fundamental type %d", typeid);
499 type
= init_type (TYPE_CODE_VOID
,
500 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
504 type
= init_type (TYPE_CODE_INT
,
505 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
509 type
= init_type (TYPE_CODE_INT
,
510 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
511 0, "signed char", objfile
);
513 case FT_UNSIGNED_CHAR
:
514 type
= init_type (TYPE_CODE_INT
,
515 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
516 TYPE_FLAG_UNSIGNED
, "unsigned char", objfile
);
519 type
= init_type (TYPE_CODE_INT
,
520 TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
521 0, "short", objfile
);
523 case FT_SIGNED_SHORT
:
524 type
= init_type (TYPE_CODE_INT
,
525 TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
526 0, "short", objfile
); /* FIXME-fnf */
528 case FT_UNSIGNED_SHORT
:
529 type
= init_type (TYPE_CODE_INT
,
530 TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
531 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
534 type
= init_type (TYPE_CODE_INT
,
535 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
538 case FT_SIGNED_INTEGER
:
539 type
= init_type (TYPE_CODE_INT
,
540 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
541 0, "int", objfile
); /* FIXME -fnf */
543 case FT_UNSIGNED_INTEGER
:
544 type
= init_type (TYPE_CODE_INT
,
545 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
546 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
549 type
= init_type (TYPE_CODE_INT
,
550 TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
554 type
= init_type (TYPE_CODE_INT
,
555 TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
556 0, "long", objfile
); /* FIXME -fnf */
558 case FT_UNSIGNED_LONG
:
559 type
= init_type (TYPE_CODE_INT
,
560 TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
561 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
564 type
= init_type (TYPE_CODE_INT
,
565 TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
566 0, "long long", objfile
);
568 case FT_SIGNED_LONG_LONG
:
569 type
= init_type (TYPE_CODE_INT
,
570 TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
571 0, "signed long long", objfile
);
573 case FT_UNSIGNED_LONG_LONG
:
574 type
= init_type (TYPE_CODE_INT
,
575 TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
576 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
579 type
= init_type (TYPE_CODE_FLT
,
580 TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
581 0, "float", objfile
);
583 case FT_DBL_PREC_FLOAT
:
584 type
= init_type (TYPE_CODE_FLT
,
585 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
586 0, "double", objfile
);
588 case FT_EXT_PREC_FLOAT
:
589 type
= init_type (TYPE_CODE_FLT
,
590 TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
591 0, "long double", objfile
);
597 /* Determine if we are currently in the Objective-C dispatch function.
598 If so, get the address of the method function that the dispatcher
599 would call and use that as the function to step into instead. Also
600 skip over the trampoline for the function (if any). This is better
601 for the user since they are only interested in stepping into the
602 method function anyway. */
604 objc_skip_trampoline (CORE_ADDR stop_pc
)
606 CORE_ADDR real_stop_pc
;
607 CORE_ADDR method_stop_pc
;
609 real_stop_pc
= SKIP_TRAMPOLINE_CODE (stop_pc
);
611 if (real_stop_pc
!= 0)
612 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
614 find_objc_msgcall (stop_pc
, &method_stop_pc
);
618 real_stop_pc
= SKIP_TRAMPOLINE_CODE (method_stop_pc
);
619 if (real_stop_pc
== 0)
620 real_stop_pc
= method_stop_pc
;
627 /* Table mapping opcodes into strings for printing operators
628 and precedences of the operators. */
630 static const struct op_print objc_op_print_tab
[] =
632 {",", BINOP_COMMA
, PREC_COMMA
, 0},
633 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
634 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
635 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
636 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
637 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
638 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
639 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
640 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
641 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
642 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
643 {">", BINOP_GTR
, PREC_ORDER
, 0},
644 {"<", BINOP_LESS
, PREC_ORDER
, 0},
645 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
646 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
647 {"+", BINOP_ADD
, PREC_ADD
, 0},
648 {"-", BINOP_SUB
, PREC_ADD
, 0},
649 {"*", BINOP_MUL
, PREC_MUL
, 0},
650 {"/", BINOP_DIV
, PREC_MUL
, 0},
651 {"%", BINOP_REM
, PREC_MUL
, 0},
652 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
653 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
654 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
655 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
656 {"*", UNOP_IND
, PREC_PREFIX
, 0},
657 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
658 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
659 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
660 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
664 struct type
** const (objc_builtin_types
[]) =
671 &builtin_type_double
,
673 &builtin_type_long_long
,
674 &builtin_type_signed_char
,
675 &builtin_type_unsigned_char
,
676 &builtin_type_unsigned_short
,
677 &builtin_type_unsigned_int
,
678 &builtin_type_unsigned_long
,
679 &builtin_type_unsigned_long_long
,
680 &builtin_type_long_double
,
681 &builtin_type_complex
,
682 &builtin_type_double_complex
,
686 const struct language_defn objc_language_defn
= {
687 "objective-c", /* Language name */
695 evaluate_subexp_standard
,
696 objc_printchar
, /* Print a character constant */
697 objc_printstr
, /* Function to print string constant */
699 objc_create_fundamental_type
, /* Create fundamental type in this language */
700 c_print_type
, /* Print a type using appropriate syntax */
701 c_val_print
, /* Print a value using appropriate syntax */
702 c_value_print
, /* Print a top-level value */
703 objc_skip_trampoline
, /* Language specific skip_trampoline */
704 objc_demangle
, /* Language specific symbol demangler */
705 {"", "", "", ""}, /* Binary format info */
706 {"0%lo", "0", "o", ""}, /* Octal format info */
707 {"%ld", "", "d", ""}, /* Decimal format info */
708 {"0x%lx", "0x", "x", ""}, /* Hex format info */
709 objc_op_print_tab
, /* Expression operators for printing */
710 1, /* C-style arrays */
711 0, /* String lower bound */
712 &builtin_type_char
, /* Type of string elements */
718 * Following functions help construct Objective-C message calls
721 struct selname
/* For parsing Objective-C. */
723 struct selname
*next
;
728 static int msglist_len
;
729 static struct selname
*selname_chain
;
730 static char *msglist_sel
;
735 register struct selname
*new =
736 (struct selname
*) xmalloc (sizeof (struct selname
));
738 new->next
= selname_chain
;
739 new->msglist_len
= msglist_len
;
740 new->msglist_sel
= msglist_sel
;
742 msglist_sel
= (char *)xmalloc(1);
748 add_msglist(struct stoken
*str
, int addcolon
)
753 if (str
== 0) { /* Unnamed arg, or... */
754 if (addcolon
== 0) { /* variable number of args. */
764 len
= plen
+ strlen(msglist_sel
) + 2;
765 s
= (char *)xmalloc(len
);
766 strcpy(s
, msglist_sel
);
781 register int val
= msglist_len
;
782 register struct selname
*sel
= selname_chain
;
783 register char *p
= msglist_sel
;
786 selname_chain
= sel
->next
;
787 msglist_len
= sel
->msglist_len
;
788 msglist_sel
= sel
->msglist_sel
;
789 selid
= lookup_child_selector(p
);
791 error("Can't find selector \"%s\"", p
);
792 write_exp_elt_longcst (selid
);
794 write_exp_elt_longcst (val
); /* Number of args */
801 * Function: specialcmp (char *a, char *b)
803 * Special strcmp: treats ']' and ' ' as end-of-string.
804 * Used for qsorting lists of objc methods (either by class or selector).
807 int specialcmp(char *a
, char *b
)
809 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
815 if (*a
&& *a
!= ' ' && *a
!= ']')
816 return 1; /* a is longer therefore greater */
817 if (*b
&& *b
!= ' ' && *b
!= ']')
818 return -1; /* a is shorter therefore lesser */
819 return 0; /* a and b are identical */
823 * Function: compare_selectors (const void *, const void *)
825 * Comparison function for use with qsort. Arguments are symbols or
826 * msymbols Compares selector part of objc method name alphabetically.
830 compare_selectors (const void *a
, const void *b
)
834 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
835 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
836 if (aname
== NULL
|| bname
== NULL
)
837 error ("internal: compare_selectors(1)");
839 aname
= strchr(aname
, ' ');
840 bname
= strchr(bname
, ' ');
841 if (aname
== NULL
|| bname
== NULL
)
842 error ("internal: compare_selectors(2)");
844 return specialcmp (aname
+1, bname
+1);
848 * Function: selectors_info (regexp, from_tty)
850 * Implements the "Info selectors" command. Takes an optional regexp
851 * arg. Lists all objective c selectors that match the regexp. Works
852 * by grepping thru all symbols for objective c methods. Output list
853 * is sorted and uniqued.
857 selectors_info (char *regexp
, int from_tty
)
859 struct objfile
*objfile
;
860 struct minimal_symbol
*msymbol
;
868 struct symbol
**sym_arr
;
872 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
875 if (*regexp
== '+' || *regexp
== '-')
876 { /* User wants only class methods or only instance methods. */
877 plusminus
= *regexp
++;
878 while (*regexp
== ' ' || *regexp
== '\t')
882 strcpy(myregexp
, ".*]");
885 strcpy(myregexp
, regexp
);
886 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
887 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
889 strcat(myregexp
, ".*]");
895 val
= re_comp (myregexp
);
897 error ("Invalid regexp (%s): %s", val
, regexp
);
900 /* First time thru is JUST to get max length and count. */
901 ALL_MSYMBOLS (objfile
, msymbol
)
904 name
= SYMBOL_NATURAL_NAME (msymbol
);
906 (name
[0] == '-' || name
[0] == '+') &&
907 name
[1] == '[') /* Got a method name. */
909 /* Filter for class/instance methods. */
910 if (plusminus
&& name
[0] != plusminus
)
912 /* Find selector part. */
913 name
= (char *) strchr(name
+2, ' ');
914 if (regexp
== NULL
|| re_exec(++name
) != 0)
916 char *mystart
= name
;
917 char *myend
= (char *) strchr(mystart
, ']');
919 if (myend
&& (myend
- mystart
> maxlen
))
920 maxlen
= myend
- mystart
; /* Get longest selector. */
927 printf_filtered ("Selectors matching \"%s\":\n\n",
928 regexp
? regexp
: "*");
930 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
932 ALL_MSYMBOLS (objfile
, msymbol
)
935 name
= SYMBOL_NATURAL_NAME (msymbol
);
937 (name
[0] == '-' || name
[0] == '+') &&
938 name
[1] == '[') /* Got a method name. */
940 /* Filter for class/instance methods. */
941 if (plusminus
&& name
[0] != plusminus
)
943 /* Find selector part. */
944 name
= (char *) strchr(name
+2, ' ');
945 if (regexp
== NULL
|| re_exec(++name
) != 0)
946 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
950 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
952 /* Prevent compare on first iteration. */
954 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
959 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
960 name
= strchr (name
, ' ') + 1;
961 if (p
[0] && specialcmp(name
, p
) == 0)
962 continue; /* Seen this one already (not unique). */
964 /* Copy selector part. */
965 while (*name
&& *name
!= ']')
968 /* Print in columns. */
969 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
974 printf_filtered ("No selectors matching \"%s\"\n", regexp
? regexp
: "*");
978 * Function: compare_classes (const void *, const void *)
980 * Comparison function for use with qsort. Arguments are symbols or
981 * msymbols Compares class part of objc method name alphabetically.
985 compare_classes (const void *a
, const void *b
)
989 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
990 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
991 if (aname
== NULL
|| bname
== NULL
)
992 error ("internal: compare_classes(1)");
994 return specialcmp (aname
+1, bname
+1);
998 * Function: classes_info(regexp, from_tty)
1000 * Implements the "info classes" command for objective c classes.
1001 * Lists all objective c classes that match the optional regexp.
1002 * Works by grepping thru the list of objective c methods. List will
1003 * be sorted and uniqued (since one class may have many methods).
1004 * BUGS: will not list a class that has no methods.
1008 classes_info (char *regexp
, int from_tty
)
1010 struct objfile
*objfile
;
1011 struct minimal_symbol
*msymbol
;
1017 char myregexp
[2048];
1019 struct symbol
**sym_arr
;
1022 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
1025 strcpy(myregexp
, regexp
);
1026 if (myregexp
[strlen(myregexp
) - 1] == '$')
1027 /* In the method name, the end of the class name is marked by ' '. */
1028 myregexp
[strlen(myregexp
) - 1] = ' ';
1030 strcat(myregexp
, ".* ");
1035 val
= re_comp (myregexp
);
1037 error ("Invalid regexp (%s): %s", val
, regexp
);
1040 /* First time thru is JUST to get max length and count. */
1041 ALL_MSYMBOLS (objfile
, msymbol
)
1044 name
= SYMBOL_NATURAL_NAME (msymbol
);
1046 (name
[0] == '-' || name
[0] == '+') &&
1047 name
[1] == '[') /* Got a method name. */
1048 if (regexp
== NULL
|| re_exec(name
+2) != 0)
1050 /* Compute length of classname part. */
1051 char *mystart
= name
+ 2;
1052 char *myend
= (char *) strchr(mystart
, ' ');
1054 if (myend
&& (myend
- mystart
> maxlen
))
1055 maxlen
= myend
- mystart
;
1061 printf_filtered ("Classes matching \"%s\":\n\n",
1062 regexp
? regexp
: "*");
1063 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
1065 ALL_MSYMBOLS (objfile
, msymbol
)
1068 name
= SYMBOL_NATURAL_NAME (msymbol
);
1070 (name
[0] == '-' || name
[0] == '+') &&
1071 name
[1] == '[') /* Got a method name. */
1072 if (regexp
== NULL
|| re_exec(name
+2) != 0)
1073 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
1076 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
1078 /* Prevent compare on first iteration. */
1080 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
1085 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
1087 if (p
[0] && specialcmp(name
, p
) == 0)
1088 continue; /* Seen this one already (not unique). */
1090 /* Copy class part of method name. */
1091 while (*name
&& *name
!= ' ')
1094 /* Print in columns. */
1095 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
1100 printf_filtered ("No classes matching \"%s\"\n", regexp
? regexp
: "*");
1104 * Function: find_imps (char *selector, struct symbol **sym_arr)
1106 * Input: a string representing a selector
1107 * a pointer to an array of symbol pointers
1108 * possibly a pointer to a symbol found by the caller.
1110 * Output: number of methods that implement that selector. Side
1111 * effects: The array of symbol pointers is filled with matching syms.
1113 * By analogy with function "find_methods" (symtab.c), builds a list
1114 * of symbols matching the ambiguous input, so that "decode_line_2"
1115 * (symtab.c) can list them and ask the user to choose one or more.
1116 * In this case the matches are objective c methods
1117 * ("implementations") matching an objective c selector.
1119 * Note that it is possible for a normal (c-style) function to have
1120 * the same name as an objective c selector. To prevent the selector
1121 * from eclipsing the function, we allow the caller (decode_line_1) to
1122 * search for such a function first, and if it finds one, pass it in
1123 * to us. We will then integrate it into the list. We also search
1124 * for one here, among the minsyms.
1126 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1127 * into two parts: debuggable (struct symbol) syms, and
1128 * non_debuggable (struct minimal_symbol) syms. The debuggable
1129 * ones will come first, before NUM_DEBUGGABLE (which will thus
1130 * be the index of the first non-debuggable one).
1134 * Function: total_number_of_imps (char *selector);
1136 * Input: a string representing a selector
1137 * Output: number of methods that implement that selector.
1139 * By analogy with function "total_number_of_methods", this allows
1140 * decode_line_1 (symtab.c) to detect if there are objective c methods
1141 * matching the input, and to allocate an array of pointers to them
1142 * which can be manipulated by "decode_line_2" (also in symtab.c).
1146 parse_selector (char *method
, char **selector
)
1150 int found_quote
= 0;
1152 char *nselector
= NULL
;
1154 CHECK (selector
!= NULL
);
1158 while (isspace (*s1
))
1165 while (isspace (*s1
))
1172 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1174 else if (isspace (*s2
))
1176 else if ((*s2
== '\0') || (*s2
== '\''))
1184 while (isspace (*s2
))
1190 while (isspace (*s2
))
1194 if (selector
!= NULL
)
1195 *selector
= nselector
;
1201 parse_method (char *method
, char *type
, char **class,
1202 char **category
, char **selector
)
1206 int found_quote
= 0;
1209 char *nclass
= NULL
;
1210 char *ncategory
= NULL
;
1211 char *nselector
= NULL
;
1213 CHECK (type
!= NULL
);
1214 CHECK (class != NULL
);
1215 CHECK (category
!= NULL
);
1216 CHECK (selector
!= NULL
);
1220 while (isspace (*s1
))
1227 while (isspace (*s1
))
1230 if ((s1
[0] == '+') || (s1
[0] == '-'))
1233 while (isspace (*s1
))
1241 while (isalnum (*s1
) || (*s1
== '_'))
1245 while (isspace (*s2
))
1251 while (isspace (*s2
))
1254 while (isalnum (*s2
) || (*s2
== '_'))
1259 /* Truncate the class name now that we're not using the open paren. */
1266 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1268 else if (isspace (*s2
))
1270 else if (*s2
== ']')
1279 while (isspace (*s2
))
1286 while (isspace (*s2
))
1294 if (category
!= NULL
)
1295 *category
= ncategory
;
1296 if (selector
!= NULL
)
1297 *selector
= nselector
;
1303 find_methods (struct symtab
*symtab
, char type
,
1304 const char *class, const char *category
,
1305 const char *selector
, struct symbol
**syms
,
1306 unsigned int *nsym
, unsigned int *ndebug
)
1308 struct objfile
*objfile
= NULL
;
1309 struct minimal_symbol
*msymbol
= NULL
;
1310 struct block
*block
= NULL
;
1311 struct symbol
*sym
= NULL
;
1313 char *symname
= NULL
;
1316 char *nclass
= NULL
;
1317 char *ncategory
= NULL
;
1318 char *nselector
= NULL
;
1320 unsigned int csym
= 0;
1321 unsigned int cdebug
= 0;
1323 static char *tmp
= NULL
;
1324 static unsigned int tmplen
= 0;
1326 CHECK (nsym
!= NULL
);
1327 CHECK (ndebug
!= NULL
);
1330 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1332 ALL_MSYMBOLS (objfile
, msymbol
)
1336 if ((msymbol
->type
!= mst_text
) && (msymbol
->type
!= mst_file_text
))
1337 /* Not a function or method. */
1341 if ((SYMBOL_VALUE_ADDRESS (msymbol
) < BLOCK_START (block
)) ||
1342 (SYMBOL_VALUE_ADDRESS (msymbol
) >= BLOCK_END (block
)))
1343 /* Not in the specified symtab. */
1346 symname
= SYMBOL_NATURAL_NAME (msymbol
);
1347 if (symname
== NULL
)
1350 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1351 /* Not a method name. */
1354 while ((strlen (symname
) + 1) >= tmplen
)
1356 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1357 tmp
= xrealloc (tmp
, tmplen
);
1359 strcpy (tmp
, symname
);
1361 if (parse_method (tmp
, &ntype
, &nclass
, &ncategory
, &nselector
) == NULL
)
1364 if ((type
!= '\0') && (ntype
!= type
))
1368 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1371 if ((category
!= NULL
) &&
1372 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1375 if ((selector
!= NULL
) &&
1376 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1379 sym
= find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol
));
1382 const char *newsymname
= SYMBOL_NATURAL_NAME (sym
);
1384 if (strcmp (symname
, newsymname
) == 0)
1386 /* Found a high-level method sym: swap it into the
1387 lower part of sym_arr (below num_debuggable). */
1390 syms
[csym
] = syms
[cdebug
];
1399 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1400 newsymname
, symname
);
1402 syms
[csym
] = (struct symbol
*) msymbol
;
1408 /* Found a non-debuggable method symbol. */
1410 syms
[csym
] = (struct symbol
*) msymbol
;
1421 char *find_imps (struct symtab
*symtab
, struct block
*block
,
1422 char *method
, struct symbol
**syms
,
1423 unsigned int *nsym
, unsigned int *ndebug
)
1427 char *category
= NULL
;
1428 char *selector
= NULL
;
1430 unsigned int csym
= 0;
1431 unsigned int cdebug
= 0;
1433 unsigned int ncsym
= 0;
1434 unsigned int ncdebug
= 0;
1439 CHECK (nsym
!= NULL
);
1440 CHECK (ndebug
!= NULL
);
1447 buf
= (char *) alloca (strlen (method
) + 1);
1448 strcpy (buf
, method
);
1449 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1453 struct symtab
*sym_symtab
= NULL
;
1454 struct symbol
*sym
= NULL
;
1455 struct minimal_symbol
*msym
= NULL
;
1457 strcpy (buf
, method
);
1458 tmp
= parse_selector (buf
, &selector
);
1463 sym
= lookup_symbol (selector
, block
, VAR_NAMESPACE
, 0, &sym_symtab
);
1473 msym
= lookup_minimal_symbol (selector
, 0, 0);
1478 syms
[csym
] = (struct symbol
*)msym
;
1484 find_methods (symtab
, type
, class, category
, selector
,
1485 syms
+ csym
, &ncsym
, &ncdebug
);
1487 find_methods (symtab
, type
, class, category
, selector
,
1488 NULL
, &ncsym
, &ncdebug
);
1490 /* If we didn't find any methods, just return. */
1491 if (ncsym
== 0 && ncdebug
== 0)
1494 /* Take debug symbols from the second batch of symbols and swap them
1495 * with debug symbols from the first batch. Repeat until either the
1496 * second section is out of debug symbols or the first section is
1497 * full of debug symbols. Either way we have all debug symbols
1498 * packed to the beginning of the buffer.
1503 while ((cdebug
< csym
) && (ncdebug
> 0))
1505 struct symbol
*s
= NULL
;
1506 /* First non-debugging symbol. */
1507 unsigned int i
= cdebug
;
1508 /* Last of second batch of debug symbols. */
1509 unsigned int j
= csym
+ ncdebug
- 1;
1515 /* We've moved a symbol from the second debug section to the
1531 return method
+ (tmp
- buf
);
1535 /* Sort debuggable symbols. */
1537 qsort (syms
, cdebug
, sizeof (struct minimal_symbol
*),
1540 /* Sort minimal_symbols. */
1541 if ((csym
- cdebug
) > 1)
1542 qsort (&syms
[cdebug
], csym
- cdebug
,
1543 sizeof (struct minimal_symbol
*), compare_classes
);
1545 /* Terminate the sym_arr list. */
1548 return method
+ (tmp
- buf
);
1552 print_object_command (char *args
, int from_tty
)
1554 struct value
*object
, *function
, *description
;
1555 CORE_ADDR string_addr
, object_addr
;
1559 if (!args
|| !*args
)
1561 "The 'print-object' command requires an argument (an Objective-C object)");
1564 struct expression
*expr
= parse_expression (args
);
1565 register struct cleanup
*old_chain
=
1566 make_cleanup (free_current_contents
, &expr
);
1569 object
= expr
->language_defn
->evaluate_exp (builtin_type_void_data_ptr
,
1570 expr
, &pc
, EVAL_NORMAL
);
1571 do_cleanups (old_chain
);
1574 /* Validate the address for sanity. */
1575 object_addr
= value_as_long (object
);
1576 read_memory (object_addr
, &c
, 1);
1578 function
= find_function_in_inferior ("_NSPrintForDebugger");
1579 if (function
== NULL
)
1580 error ("Unable to locate _NSPrintForDebugger in child process");
1582 description
= call_function_by_hand (function
, 1, &object
);
1584 string_addr
= value_as_long (description
);
1585 if (string_addr
== 0)
1586 error ("object returns null description");
1588 read_memory (string_addr
+ i
++, &c
, 1);
1591 { /* Read and print characters up to EOS. */
1593 printf_filtered ("%c", c
);
1594 read_memory (string_addr
+ i
++, &c
, 1);
1597 printf_filtered("<object returns empty description>");
1598 printf_filtered ("\n");
1601 /* The data structure 'methcalls' is used to detect method calls (thru
1602 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1603 * and ultimately find the method being called.
1606 struct objc_methcall
{
1608 /* Return instance method to be called. */
1609 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1610 /* Start of pc range corresponding to method invocation. */
1612 /* End of pc range corresponding to method invocation. */
1616 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1617 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1618 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1619 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1621 static struct objc_methcall methcalls
[] = {
1622 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1623 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1624 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1625 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1626 { "_objc_getClass", NULL
, 0, 0},
1627 { "_objc_getMetaClass", NULL
, 0, 0}
1630 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1632 /* The following function, "find_objc_msgsend", fills in the data
1633 * structure "objc_msgs" by finding the addresses of each of the
1634 * (currently four) functions that it holds (of which objc_msgSend is
1635 * the first). This must be called each time symbols are loaded, in
1636 * case the functions have moved for some reason.
1640 find_objc_msgsend (void)
1643 for (i
= 0; i
< nmethcalls
; i
++) {
1645 struct minimal_symbol
*func
;
1647 /* Try both with and without underscore. */
1648 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1649 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_')) {
1650 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1653 methcalls
[i
].begin
= 0;
1654 methcalls
[i
].end
= 0;
1658 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1660 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1661 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
1665 /* find_objc_msgcall (replaces pc_off_limits)
1667 * ALL that this function now does is to determine whether the input
1668 * address ("pc") is the address of one of the Objective-C message
1669 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1670 * if so, it returns the address of the method that will be called.
1672 * The old function "pc_off_limits" used to do a lot of other things
1673 * in addition, such as detecting shared library jump stubs and
1674 * returning the address of the shlib function that would be called.
1675 * That functionality has been moved into the SKIP_TRAMPOLINE_CODE and
1676 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1677 * dependent modules.
1680 struct objc_submethod_helper_data
{
1681 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1687 find_objc_msgcall_submethod_helper (void * arg
)
1689 struct objc_submethod_helper_data
*s
=
1690 (struct objc_submethod_helper_data
*) arg
;
1692 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1699 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1703 struct objc_submethod_helper_data s
;
1709 if (catch_errors (find_objc_msgcall_submethod_helper
,
1711 "Unable to determine target of Objective-C method call (ignoring):\n",
1712 RETURN_MASK_ALL
) == 0)
1719 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1723 find_objc_msgsend ();
1729 for (i
= 0; i
< nmethcalls
; i
++)
1730 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1732 if (methcalls
[i
].stop_at
!= NULL
)
1733 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1743 _initialize_objc_language (void)
1745 add_language (&objc_language_defn
);
1746 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1747 "All Objective-C selectors, or those matching REGEXP.");
1748 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1749 "All Objective-C classes, or those matching REGEXP.");
1750 add_com ("print-object", class_vars
, print_object_command
,
1751 "Ask an Objective-C object to print itself.");
1752 add_com_alias ("po", "print-object", class_vars
, 1);
1756 /* Disable these functions until we put them in the gdbarch vector. */
1757 static unsigned long FETCH_ARGUMENT (int i
)
1759 internal_error (__FILE__
, __LINE__
, "FETCH_ARGUMENT not implemented");
1762 static CORE_ADDR
CONVERT_FUNCPTR (CORE_ADDR pc
)
1764 internal_error (__FILE__
, __LINE__
, "CONVERT_FUNCPTR not implemented");
1768 #if defined (__powerpc__) || defined (__ppc__)
1769 static unsigned long FETCH_ARGUMENT (int i
)
1771 return read_register (3 + i
);
1773 #elif defined (__i386__)
1774 static unsigned long FETCH_ARGUMENT (int i
)
1776 CORE_ADDR stack
= read_register (SP_REGNUM
);
1777 return read_memory_unsigned_integer (stack
+ (4 * (i
+ 1)), 4);
1779 #elif defined (__sparc__)
1780 static unsigned long FETCH_ARGUMENT (int i
)
1782 return read_register (O0_REGNUM
+ i
);
1784 #elif defined (__hppa__) || defined (__hppa)
1785 static unsigned long FETCH_ARGUMENT (int i
)
1787 return read_register (R0_REGNUM
+ 26 - i
);
1790 #error unknown architecture
1793 #if defined (__hppa__) || defined (__hppa)
1794 static CORE_ADDR
CONVERT_FUNCPTR (CORE_ADDR pc
)
1797 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, 4);
1802 static CORE_ADDR
CONVERT_FUNCPTR (CORE_ADDR pc
)
1810 read_objc_method (CORE_ADDR addr
, struct objc_method
*method
)
1812 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4);
1813 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4);
1814 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4);
1818 unsigned long read_objc_methlist_nmethods (CORE_ADDR addr
)
1820 return read_memory_unsigned_integer (addr
+ 4, 4);
1824 read_objc_methlist_method (CORE_ADDR addr
, unsigned long num
,
1825 struct objc_method
*method
)
1827 CHECK_FATAL (num
< read_objc_methlist_nmethods (addr
));
1828 read_objc_method (addr
+ 8 + (12 * num
), method
);
1832 read_objc_object (CORE_ADDR addr
, struct objc_object
*object
)
1834 object
->isa
= read_memory_unsigned_integer (addr
, 4);
1838 read_objc_super (CORE_ADDR addr
, struct objc_super
*super
)
1840 super
->receiver
= read_memory_unsigned_integer (addr
, 4);
1841 super
->class = read_memory_unsigned_integer (addr
+ 4, 4);
1845 read_objc_class (CORE_ADDR addr
, struct objc_class
*class)
1847 class->isa
= read_memory_unsigned_integer (addr
, 4);
1848 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4);
1849 class->name
= read_memory_unsigned_integer (addr
+ 8, 4);
1850 class->version
= read_memory_unsigned_integer (addr
+ 12, 4);
1851 class->info
= read_memory_unsigned_integer (addr
+ 16, 4);
1852 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4);
1853 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4);
1854 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4);
1855 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4);
1856 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4);
1860 find_implementation_from_class (CORE_ADDR
class, CORE_ADDR sel
)
1862 CORE_ADDR subclass
= class;
1864 while (subclass
!= 0)
1867 struct objc_class class_str
;
1868 unsigned mlistnum
= 0;
1870 read_objc_class (subclass
, &class_str
);
1875 unsigned long nmethods
;
1878 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1883 nmethods
= read_objc_methlist_nmethods (mlist
);
1885 for (i
= 0; i
< nmethods
; i
++)
1887 struct objc_method meth_str
;
1888 read_objc_methlist_method (mlist
, i
, &meth_str
);
1892 "checking method 0x%lx against selector 0x%lx\n",
1893 meth_str
.name
, sel
);
1896 if (meth_str
.name
== sel
)
1897 return CONVERT_FUNCPTR (meth_str
.imp
);
1901 subclass
= class_str
.super_class
;
1908 find_implementation (CORE_ADDR object
, CORE_ADDR sel
)
1910 struct objc_object ostr
;
1914 read_objc_object (object
, &ostr
);
1918 return find_implementation_from_class (ostr
.isa
, sel
);
1922 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1928 object
= FETCH_ARGUMENT (0);
1929 sel
= FETCH_ARGUMENT (1);
1931 res
= find_implementation (object
, sel
);
1940 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1946 object
= FETCH_ARGUMENT (1);
1947 sel
= FETCH_ARGUMENT (2);
1949 res
= find_implementation (object
, sel
);
1958 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1960 struct objc_super sstr
;
1966 super
= FETCH_ARGUMENT (0);
1967 sel
= FETCH_ARGUMENT (1);
1969 read_objc_super (super
, &sstr
);
1970 if (sstr
.class == 0)
1973 res
= find_implementation_from_class (sstr
.class, sel
);
1982 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1984 struct objc_super sstr
;
1990 super
= FETCH_ARGUMENT (1);
1991 sel
= FETCH_ARGUMENT (2);
1993 read_objc_super (super
, &sstr
);
1994 if (sstr
.class == 0)
1997 res
= find_implementation_from_class (sstr
.class, sel
);