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"
54 CORE_ADDR super_class
;
76 /* Complaints about ObjC classes, selectors, etc. */
78 #if (!defined __GNUC__ || __GNUC__ < 2 || __GNUC_MINOR__ < (defined __cplusplus ? 6 : 4))
79 #define __CHECK_FUNCTION ((__const char *) 0)
81 #define __CHECK_FUNCTION __PRETTY_FUNCTION__
84 #define CHECK(expression) \
85 ((void) ((expression) ? 0 : gdb_check (#expression, __FILE__, __LINE__, \
88 #define CHECK_FATAL(expression) \
89 ((void) ((expression) ? 0 : gdb_check_fatal (#expression, __FILE__, \
90 __LINE__, __CHECK_FUNCTION)))
93 gdb_check (const char *str
, const char *file
,
94 unsigned int line
, const char *func
)
96 error ("assertion failure on line %u of \"%s\" in function \"%s\": %s\n",
97 line
, file
, func
, str
);
101 gdb_check_fatal (const char *str
, const char *file
,
102 unsigned int line
, const char *func
)
104 internal_error (file
, line
,
105 "assertion failure in function \"%s\": %s\n", func
, str
);
108 /* Lookup a structure type named "struct NAME", visible in lexical
109 block BLOCK. If NOERR is nonzero, return zero if NAME is not
113 lookup_struct_typedef (char *name
, struct block
*block
, int noerr
)
115 register struct symbol
*sym
;
117 sym
= lookup_symbol (name
, block
, STRUCT_NAMESPACE
, 0,
118 (struct symtab
**) NULL
);
125 error ("No struct type named %s.", name
);
127 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_STRUCT
)
132 error ("This context has class, union or enum %s, not a struct.",
139 lookup_objc_class (char *classname
)
141 struct value
* function
, *classval
;
143 if (! target_has_execution
)
145 /* Can't call into inferior to lookup class. */
149 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
150 function
= find_function_in_inferior("objc_lookUpClass");
151 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
152 function
= find_function_in_inferior("objc_lookup_class");
155 complaint (&symfile_complaints
, "no way to lookup Objective-C classes");
159 classval
= value_string (classname
, strlen (classname
) + 1);
160 classval
= value_coerce_array (classval
);
161 return (CORE_ADDR
) value_as_long (call_function_by_hand (function
,
166 lookup_child_selector (char *selname
)
168 struct value
* function
, *selstring
;
170 if (! target_has_execution
)
172 /* Can't call into inferior to lookup selector. */
176 if (lookup_minimal_symbol("sel_getUid", 0, 0))
177 function
= find_function_in_inferior("sel_getUid");
178 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
179 function
= find_function_in_inferior("sel_get_any_uid");
182 complaint (&symfile_complaints
, "no way to lookup Objective-C selectors");
186 selstring
= value_coerce_array (value_string (selname
,
187 strlen (selname
) + 1));
188 return value_as_long (call_function_by_hand (function
, 1, &selstring
));
192 value_nsstring (char *ptr
, int len
)
194 struct value
*stringValue
[3];
195 struct value
*function
, *nsstringValue
;
199 if (!target_has_execution
)
200 return 0; /* Can't call into inferior to create NSString. */
202 sym
= lookup_struct_typedef("NSString", 0, 1);
204 sym
= lookup_struct_typedef("NXString", 0, 1);
206 type
= lookup_pointer_type(builtin_type_void
);
208 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
210 stringValue
[2] = value_string(ptr
, len
);
211 stringValue
[2] = value_coerce_array(stringValue
[2]);
212 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
213 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
215 function
= find_function_in_inferior("_NSNewStringFromCString");
216 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
218 else if (lookup_minimal_symbol("istr", 0, 0))
220 function
= find_function_in_inferior("istr");
221 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
223 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
225 function
= find_function_in_inferior("+[NSString stringWithCString:]");
226 stringValue
[0] = value_from_longest
227 (builtin_type_long
, lookup_objc_class ("NSString"));
228 stringValue
[1] = value_from_longest
229 (builtin_type_long
, lookup_child_selector ("stringWithCString:"));
230 nsstringValue
= call_function_by_hand(function
, 3, &stringValue
[0]);
233 error ("NSString: internal error -- no way to create new NSString");
235 VALUE_TYPE(nsstringValue
) = type
;
236 return nsstringValue
;
239 /* Objective-C name demangling. */
242 objc_demangle (const char *mangled
, int options
)
244 char *demangled
, *cp
;
246 if (mangled
[0] == '_' &&
247 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
250 cp
= demangled
= xmalloc(strlen(mangled
) + 2);
252 if (mangled
[1] == 'i')
253 *cp
++ = '-'; /* for instance method */
255 *cp
++ = '+'; /* for class method */
257 *cp
++ = '['; /* opening left brace */
258 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
260 while (*cp
&& *cp
== '_')
261 cp
++; /* skip any initial underbars in class name */
263 cp
= strchr(cp
, '_');
264 if (!cp
) /* find first non-initial underbar */
266 xfree(demangled
); /* not mangled name */
269 if (cp
[1] == '_') { /* easy case: no category name */
270 *cp
++ = ' '; /* replace two '_' with one ' ' */
271 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
274 *cp
++ = '('; /* less easy case: category name */
275 cp
= strchr(cp
, '_');
278 xfree(demangled
); /* not mangled name */
282 *cp
++ = ' '; /* overwriting 1st char of method name... */
283 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
286 while (*cp
&& *cp
== '_')
287 cp
++; /* skip any initial underbars in method name */
291 *cp
= ':'; /* replace remaining '_' with ':' */
293 *cp
++ = ']'; /* closing right brace */
294 *cp
++ = 0; /* string terminator */
298 return NULL
; /* Not an objc mangled name. */
301 /* Print the character C on STREAM as part of the contents of a
302 literal string whose delimiter is QUOTER. Note that that format
303 for printing characters and strings is language specific. */
306 objc_emit_char (register int c
, struct ui_file
*stream
, int quoter
)
309 c
&= 0xFF; /* Avoid sign bit follies. */
311 if (PRINT_LITERAL_FORM (c
))
313 if (c
== '\\' || c
== quoter
)
315 fputs_filtered ("\\", stream
);
317 fprintf_filtered (stream
, "%c", c
);
324 fputs_filtered ("\\n", stream
);
327 fputs_filtered ("\\b", stream
);
330 fputs_filtered ("\\t", stream
);
333 fputs_filtered ("\\f", stream
);
336 fputs_filtered ("\\r", stream
);
339 fputs_filtered ("\\e", stream
);
342 fputs_filtered ("\\a", stream
);
345 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
352 objc_printchar (int c
, struct ui_file
*stream
)
354 fputs_filtered ("'", stream
);
355 objc_emit_char (c
, stream
, '\'');
356 fputs_filtered ("'", stream
);
359 /* Print the character string STRING, printing at most LENGTH
360 characters. Printing stops early if the number hits print_max;
361 repeat counts are printed as appropriate. Print ellipses at the
362 end if we had to stop before printing LENGTH characters, or if
366 objc_printstr (struct ui_file
*stream
, char *string
,
367 unsigned int length
, int width
, int force_ellipses
)
369 register unsigned int i
;
370 unsigned int things_printed
= 0;
373 extern int inspect_it
;
375 /* If the string was not truncated due to `set print elements', and
376 the last byte of it is a null, we don't print that, in
377 traditional C style. */
378 if ((!force_ellipses
) && length
> 0 && string
[length
-1] == '\0')
383 fputs_filtered ("\"\"", stream
);
387 for (i
= 0; i
< length
&& things_printed
< print_max
; ++i
)
389 /* Position of the character we are examining to see whether it
392 /* Number of repetitions we have detected so far. */
399 fputs_filtered (", ", stream
);
405 while (rep1
< length
&& string
[rep1
] == string
[i
])
411 if (reps
> repeat_count_threshold
)
416 fputs_filtered ("\\\", ", stream
);
418 fputs_filtered ("\", ", stream
);
421 objc_printchar (string
[i
], stream
);
422 fprintf_filtered (stream
, " <repeats %u times>", reps
);
424 things_printed
+= repeat_count_threshold
;
432 fputs_filtered ("\\\"", stream
);
434 fputs_filtered ("\"", stream
);
437 objc_emit_char (string
[i
], stream
, '"');
442 /* Terminate the quotes if necessary. */
446 fputs_filtered ("\\\"", stream
);
448 fputs_filtered ("\"", stream
);
451 if (force_ellipses
|| i
< length
)
452 fputs_filtered ("...", stream
);
455 /* Create a fundamental C type using default reasonable for the
458 Some object/debugging file formats (DWARF version 1, COFF, etc) do
459 not define fundamental types such as "int" or "double". Others
460 (stabs or DWARF version 2, etc) do define fundamental types. For
461 the formats which don't provide fundamental types, gdb can create
462 such types using this function.
464 FIXME: Some compilers distinguish explicitly signed integral types
465 (signed short, signed int, signed long) from "regular" integral
466 types (short, int, long) in the debugging information. There is
467 some disagreement as to how useful this feature is. In particular,
468 gcc does not support this. Also, only some debugging formats allow
469 the distinction to be passed on to a debugger. For now, we always
470 just use "short", "int", or "long" as the type name, for both the
471 implicit and explicitly signed types. This also makes life easier
472 for the gdb test suite since we don't have to account for the
473 differences in output depending upon what the compiler and
474 debugging format support. We will probably have to re-examine the
475 issue when gdb starts taking it's fundamental type information
476 directly from the debugging information supplied by the compiler.
480 objc_create_fundamental_type (struct objfile
*objfile
, int typeid)
482 register struct type
*type
= NULL
;
487 /* FIXME: For now, if we are asked to produce a type not in
488 this language, create the equivalent of a C integer type
489 with the name "<?type?>". When all the dust settles from
490 the type reconstruction work, this should probably become
492 type
= init_type (TYPE_CODE_INT
,
493 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
494 0, "<?type?>", objfile
);
495 warning ("internal error: no C/C++ fundamental type %d", typeid);
498 type
= init_type (TYPE_CODE_VOID
,
499 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
503 type
= init_type (TYPE_CODE_INT
,
504 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
508 type
= init_type (TYPE_CODE_INT
,
509 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
510 0, "signed char", objfile
);
512 case FT_UNSIGNED_CHAR
:
513 type
= init_type (TYPE_CODE_INT
,
514 TARGET_CHAR_BIT
/ TARGET_CHAR_BIT
,
515 TYPE_FLAG_UNSIGNED
, "unsigned char", objfile
);
518 type
= init_type (TYPE_CODE_INT
,
519 TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
520 0, "short", objfile
);
522 case FT_SIGNED_SHORT
:
523 type
= init_type (TYPE_CODE_INT
,
524 TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
525 0, "short", objfile
); /* FIXME-fnf */
527 case FT_UNSIGNED_SHORT
:
528 type
= init_type (TYPE_CODE_INT
,
529 TARGET_SHORT_BIT
/ TARGET_CHAR_BIT
,
530 TYPE_FLAG_UNSIGNED
, "unsigned short", objfile
);
533 type
= init_type (TYPE_CODE_INT
,
534 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
537 case FT_SIGNED_INTEGER
:
538 type
= init_type (TYPE_CODE_INT
,
539 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
540 0, "int", objfile
); /* FIXME -fnf */
542 case FT_UNSIGNED_INTEGER
:
543 type
= init_type (TYPE_CODE_INT
,
544 TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
545 TYPE_FLAG_UNSIGNED
, "unsigned int", objfile
);
548 type
= init_type (TYPE_CODE_INT
,
549 TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
553 type
= init_type (TYPE_CODE_INT
,
554 TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
555 0, "long", objfile
); /* FIXME -fnf */
557 case FT_UNSIGNED_LONG
:
558 type
= init_type (TYPE_CODE_INT
,
559 TARGET_LONG_BIT
/ TARGET_CHAR_BIT
,
560 TYPE_FLAG_UNSIGNED
, "unsigned long", objfile
);
563 type
= init_type (TYPE_CODE_INT
,
564 TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
565 0, "long long", objfile
);
567 case FT_SIGNED_LONG_LONG
:
568 type
= init_type (TYPE_CODE_INT
,
569 TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
570 0, "signed long long", objfile
);
572 case FT_UNSIGNED_LONG_LONG
:
573 type
= init_type (TYPE_CODE_INT
,
574 TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
,
575 TYPE_FLAG_UNSIGNED
, "unsigned long long", objfile
);
578 type
= init_type (TYPE_CODE_FLT
,
579 TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
,
580 0, "float", objfile
);
582 case FT_DBL_PREC_FLOAT
:
583 type
= init_type (TYPE_CODE_FLT
,
584 TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
585 0, "double", objfile
);
587 case FT_EXT_PREC_FLOAT
:
588 type
= init_type (TYPE_CODE_FLT
,
589 TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
,
590 0, "long double", objfile
);
596 /* Determine if we are currently in the Objective-C dispatch function.
597 If so, get the address of the method function that the dispatcher
598 would call and use that as the function to step into instead. Also
599 skip over the trampoline for the function (if any). This is better
600 for the user since they are only interested in stepping into the
601 method function anyway. */
603 objc_skip_trampoline (CORE_ADDR stop_pc
)
605 CORE_ADDR real_stop_pc
;
606 CORE_ADDR method_stop_pc
;
608 real_stop_pc
= SKIP_TRAMPOLINE_CODE (stop_pc
);
610 if (real_stop_pc
!= 0)
611 find_objc_msgcall (real_stop_pc
, &method_stop_pc
);
613 find_objc_msgcall (stop_pc
, &method_stop_pc
);
617 real_stop_pc
= SKIP_TRAMPOLINE_CODE (method_stop_pc
);
618 if (real_stop_pc
== 0)
619 real_stop_pc
= method_stop_pc
;
626 /* Table mapping opcodes into strings for printing operators
627 and precedences of the operators. */
629 static const struct op_print objc_op_print_tab
[] =
631 {",", BINOP_COMMA
, PREC_COMMA
, 0},
632 {"=", BINOP_ASSIGN
, PREC_ASSIGN
, 1},
633 {"||", BINOP_LOGICAL_OR
, PREC_LOGICAL_OR
, 0},
634 {"&&", BINOP_LOGICAL_AND
, PREC_LOGICAL_AND
, 0},
635 {"|", BINOP_BITWISE_IOR
, PREC_BITWISE_IOR
, 0},
636 {"^", BINOP_BITWISE_XOR
, PREC_BITWISE_XOR
, 0},
637 {"&", BINOP_BITWISE_AND
, PREC_BITWISE_AND
, 0},
638 {"==", BINOP_EQUAL
, PREC_EQUAL
, 0},
639 {"!=", BINOP_NOTEQUAL
, PREC_EQUAL
, 0},
640 {"<=", BINOP_LEQ
, PREC_ORDER
, 0},
641 {">=", BINOP_GEQ
, PREC_ORDER
, 0},
642 {">", BINOP_GTR
, PREC_ORDER
, 0},
643 {"<", BINOP_LESS
, PREC_ORDER
, 0},
644 {">>", BINOP_RSH
, PREC_SHIFT
, 0},
645 {"<<", BINOP_LSH
, PREC_SHIFT
, 0},
646 {"+", BINOP_ADD
, PREC_ADD
, 0},
647 {"-", BINOP_SUB
, PREC_ADD
, 0},
648 {"*", BINOP_MUL
, PREC_MUL
, 0},
649 {"/", BINOP_DIV
, PREC_MUL
, 0},
650 {"%", BINOP_REM
, PREC_MUL
, 0},
651 {"@", BINOP_REPEAT
, PREC_REPEAT
, 0},
652 {"-", UNOP_NEG
, PREC_PREFIX
, 0},
653 {"!", UNOP_LOGICAL_NOT
, PREC_PREFIX
, 0},
654 {"~", UNOP_COMPLEMENT
, PREC_PREFIX
, 0},
655 {"*", UNOP_IND
, PREC_PREFIX
, 0},
656 {"&", UNOP_ADDR
, PREC_PREFIX
, 0},
657 {"sizeof ", UNOP_SIZEOF
, PREC_PREFIX
, 0},
658 {"++", UNOP_PREINCREMENT
, PREC_PREFIX
, 0},
659 {"--", UNOP_PREDECREMENT
, PREC_PREFIX
, 0},
663 struct type
** const (objc_builtin_types
[]) =
670 &builtin_type_double
,
672 &builtin_type_long_long
,
673 &builtin_type_signed_char
,
674 &builtin_type_unsigned_char
,
675 &builtin_type_unsigned_short
,
676 &builtin_type_unsigned_int
,
677 &builtin_type_unsigned_long
,
678 &builtin_type_unsigned_long_long
,
679 &builtin_type_long_double
,
680 &builtin_type_complex
,
681 &builtin_type_double_complex
,
685 const struct language_defn objc_language_defn
= {
686 "objective-c", /* Language name */
694 evaluate_subexp_standard
,
695 objc_printchar
, /* Print a character constant */
696 objc_printstr
, /* Function to print string constant */
698 objc_create_fundamental_type
, /* Create fundamental type in this language */
699 c_print_type
, /* Print a type using appropriate syntax */
700 c_val_print
, /* Print a value using appropriate syntax */
701 c_value_print
, /* Print a top-level value */
702 objc_skip_trampoline
, /* Language specific skip_trampoline */
703 objc_demangle
, /* Language specific symbol demangler */
704 {"", "", "", ""}, /* Binary format info */
705 {"0%lo", "0", "o", ""}, /* Octal format info */
706 {"%ld", "", "d", ""}, /* Decimal format info */
707 {"0x%lx", "0x", "x", ""}, /* Hex format info */
708 objc_op_print_tab
, /* Expression operators for printing */
709 1, /* C-style arrays */
710 0, /* String lower bound */
711 &builtin_type_char
, /* Type of string elements */
717 * Following functions help construct Objective-C message calls
720 struct selname
/* For parsing Objective-C. */
722 struct selname
*next
;
727 static int msglist_len
;
728 static struct selname
*selname_chain
;
729 static char *msglist_sel
;
734 register struct selname
*new =
735 (struct selname
*) xmalloc (sizeof (struct selname
));
737 new->next
= selname_chain
;
738 new->msglist_len
= msglist_len
;
739 new->msglist_sel
= msglist_sel
;
741 msglist_sel
= (char *)xmalloc(1);
747 add_msglist(struct stoken
*str
, int addcolon
)
752 if (str
== 0) { /* Unnamed arg, or... */
753 if (addcolon
== 0) { /* variable number of args. */
763 len
= plen
+ strlen(msglist_sel
) + 2;
764 s
= (char *)xmalloc(len
);
765 strcpy(s
, msglist_sel
);
780 register int val
= msglist_len
;
781 register struct selname
*sel
= selname_chain
;
782 register char *p
= msglist_sel
;
785 selname_chain
= sel
->next
;
786 msglist_len
= sel
->msglist_len
;
787 msglist_sel
= sel
->msglist_sel
;
788 selid
= lookup_child_selector(p
);
790 error("Can't find selector \"%s\"", p
);
791 write_exp_elt_longcst (selid
);
793 write_exp_elt_longcst (val
); /* Number of args */
800 * Function: specialcmp (char *a, char *b)
802 * Special strcmp: treats ']' and ' ' as end-of-string.
803 * Used for qsorting lists of objc methods (either by class or selector).
806 int specialcmp(char *a
, char *b
)
808 while (*a
&& *a
!= ' ' && *a
!= ']' && *b
&& *b
!= ' ' && *b
!= ']')
814 if (*a
&& *a
!= ' ' && *a
!= ']')
815 return 1; /* a is longer therefore greater */
816 if (*b
&& *b
!= ' ' && *b
!= ']')
817 return -1; /* a is shorter therefore lesser */
818 return 0; /* a and b are identical */
822 * Function: compare_selectors (const void *, const void *)
824 * Comparison function for use with qsort. Arguments are symbols or
825 * msymbols Compares selector part of objc method name alphabetically.
829 compare_selectors (const void *a
, const void *b
)
833 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
834 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
835 if (aname
== NULL
|| bname
== NULL
)
836 error ("internal: compare_selectors(1)");
838 aname
= strchr(aname
, ' ');
839 bname
= strchr(bname
, ' ');
840 if (aname
== NULL
|| bname
== NULL
)
841 error ("internal: compare_selectors(2)");
843 return specialcmp (aname
+1, bname
+1);
847 * Function: selectors_info (regexp, from_tty)
849 * Implements the "Info selectors" command. Takes an optional regexp
850 * arg. Lists all objective c selectors that match the regexp. Works
851 * by grepping thru all symbols for objective c methods. Output list
852 * is sorted and uniqued.
856 selectors_info (char *regexp
, int from_tty
)
858 struct objfile
*objfile
;
859 struct minimal_symbol
*msymbol
;
867 struct symbol
**sym_arr
;
871 strcpy(myregexp
, ".*]"); /* Null input, match all objc methods. */
874 if (*regexp
== '+' || *regexp
== '-')
875 { /* User wants only class methods or only instance methods. */
876 plusminus
= *regexp
++;
877 while (*regexp
== ' ' || *regexp
== '\t')
881 strcpy(myregexp
, ".*]");
884 strcpy(myregexp
, regexp
);
885 if (myregexp
[strlen(myregexp
) - 1] == '$') /* end of selector */
886 myregexp
[strlen(myregexp
) - 1] = ']'; /* end of method name */
888 strcat(myregexp
, ".*]");
894 val
= re_comp (myregexp
);
896 error ("Invalid regexp (%s): %s", val
, regexp
);
899 /* First time thru is JUST to get max length and count. */
900 ALL_MSYMBOLS (objfile
, msymbol
)
903 name
= SYMBOL_NATURAL_NAME (msymbol
);
905 (name
[0] == '-' || name
[0] == '+') &&
906 name
[1] == '[') /* Got a method name. */
908 /* Filter for class/instance methods. */
909 if (plusminus
&& name
[0] != plusminus
)
911 /* Find selector part. */
912 name
= (char *) strchr(name
+2, ' ');
913 if (regexp
== NULL
|| re_exec(++name
) != 0)
915 char *mystart
= name
;
916 char *myend
= (char *) strchr(mystart
, ']');
918 if (myend
&& (myend
- mystart
> maxlen
))
919 maxlen
= myend
- mystart
; /* Get longest selector. */
926 printf_filtered ("Selectors matching \"%s\":\n\n",
927 regexp
? regexp
: "*");
929 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
931 ALL_MSYMBOLS (objfile
, msymbol
)
934 name
= SYMBOL_NATURAL_NAME (msymbol
);
936 (name
[0] == '-' || name
[0] == '+') &&
937 name
[1] == '[') /* Got a method name. */
939 /* Filter for class/instance methods. */
940 if (plusminus
&& name
[0] != plusminus
)
942 /* Find selector part. */
943 name
= (char *) strchr(name
+2, ' ');
944 if (regexp
== NULL
|| re_exec(++name
) != 0)
945 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
949 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
951 /* Prevent compare on first iteration. */
953 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
958 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
959 name
= strchr (name
, ' ') + 1;
960 if (p
[0] && specialcmp(name
, p
) == 0)
961 continue; /* Seen this one already (not unique). */
963 /* Copy selector part. */
964 while (*name
&& *name
!= ']')
967 /* Print in columns. */
968 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
973 printf_filtered ("No selectors matching \"%s\"\n", regexp
? regexp
: "*");
977 * Function: compare_classes (const void *, const void *)
979 * Comparison function for use with qsort. Arguments are symbols or
980 * msymbols Compares class part of objc method name alphabetically.
984 compare_classes (const void *a
, const void *b
)
988 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
989 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
990 if (aname
== NULL
|| bname
== NULL
)
991 error ("internal: compare_classes(1)");
993 return specialcmp (aname
+1, bname
+1);
997 * Function: classes_info(regexp, from_tty)
999 * Implements the "info classes" command for objective c classes.
1000 * Lists all objective c classes that match the optional regexp.
1001 * Works by grepping thru the list of objective c methods. List will
1002 * be sorted and uniqued (since one class may have many methods).
1003 * BUGS: will not list a class that has no methods.
1007 classes_info (char *regexp
, int from_tty
)
1009 struct objfile
*objfile
;
1010 struct minimal_symbol
*msymbol
;
1016 char myregexp
[2048];
1018 struct symbol
**sym_arr
;
1021 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
1024 strcpy(myregexp
, regexp
);
1025 if (myregexp
[strlen(myregexp
) - 1] == '$')
1026 /* In the method name, the end of the class name is marked by ' '. */
1027 myregexp
[strlen(myregexp
) - 1] = ' ';
1029 strcat(myregexp
, ".* ");
1034 val
= re_comp (myregexp
);
1036 error ("Invalid regexp (%s): %s", val
, regexp
);
1039 /* First time thru is JUST to get max length and count. */
1040 ALL_MSYMBOLS (objfile
, msymbol
)
1043 name
= SYMBOL_NATURAL_NAME (msymbol
);
1045 (name
[0] == '-' || name
[0] == '+') &&
1046 name
[1] == '[') /* Got a method name. */
1047 if (regexp
== NULL
|| re_exec(name
+2) != 0)
1049 /* Compute length of classname part. */
1050 char *mystart
= name
+ 2;
1051 char *myend
= (char *) strchr(mystart
, ' ');
1053 if (myend
&& (myend
- mystart
> maxlen
))
1054 maxlen
= myend
- mystart
;
1060 printf_filtered ("Classes matching \"%s\":\n\n",
1061 regexp
? regexp
: "*");
1062 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
1064 ALL_MSYMBOLS (objfile
, msymbol
)
1067 name
= SYMBOL_NATURAL_NAME (msymbol
);
1069 (name
[0] == '-' || name
[0] == '+') &&
1070 name
[1] == '[') /* Got a method name. */
1071 if (regexp
== NULL
|| re_exec(name
+2) != 0)
1072 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
1075 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
1077 /* Prevent compare on first iteration. */
1079 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
1084 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
1086 if (p
[0] && specialcmp(name
, p
) == 0)
1087 continue; /* Seen this one already (not unique). */
1089 /* Copy class part of method name. */
1090 while (*name
&& *name
!= ' ')
1093 /* Print in columns. */
1094 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
1099 printf_filtered ("No classes matching \"%s\"\n", regexp
? regexp
: "*");
1103 * Function: find_imps (char *selector, struct symbol **sym_arr)
1105 * Input: a string representing a selector
1106 * a pointer to an array of symbol pointers
1107 * possibly a pointer to a symbol found by the caller.
1109 * Output: number of methods that implement that selector. Side
1110 * effects: The array of symbol pointers is filled with matching syms.
1112 * By analogy with function "find_methods" (symtab.c), builds a list
1113 * of symbols matching the ambiguous input, so that "decode_line_2"
1114 * (symtab.c) can list them and ask the user to choose one or more.
1115 * In this case the matches are objective c methods
1116 * ("implementations") matching an objective c selector.
1118 * Note that it is possible for a normal (c-style) function to have
1119 * the same name as an objective c selector. To prevent the selector
1120 * from eclipsing the function, we allow the caller (decode_line_1) to
1121 * search for such a function first, and if it finds one, pass it in
1122 * to us. We will then integrate it into the list. We also search
1123 * for one here, among the minsyms.
1125 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1126 * into two parts: debuggable (struct symbol) syms, and
1127 * non_debuggable (struct minimal_symbol) syms. The debuggable
1128 * ones will come first, before NUM_DEBUGGABLE (which will thus
1129 * be the index of the first non-debuggable one).
1133 * Function: total_number_of_imps (char *selector);
1135 * Input: a string representing a selector
1136 * Output: number of methods that implement that selector.
1138 * By analogy with function "total_number_of_methods", this allows
1139 * decode_line_1 (symtab.c) to detect if there are objective c methods
1140 * matching the input, and to allocate an array of pointers to them
1141 * which can be manipulated by "decode_line_2" (also in symtab.c).
1145 parse_selector (char *method
, char **selector
)
1149 int found_quote
= 0;
1151 char *nselector
= NULL
;
1153 CHECK (selector
!= NULL
);
1157 while (isspace (*s1
))
1164 while (isspace (*s1
))
1171 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1173 else if (isspace (*s2
))
1175 else if ((*s2
== '\0') || (*s2
== '\''))
1183 while (isspace (*s2
))
1189 while (isspace (*s2
))
1193 if (selector
!= NULL
)
1194 *selector
= nselector
;
1200 parse_method (char *method
, char *type
, char **class,
1201 char **category
, char **selector
)
1205 int found_quote
= 0;
1208 char *nclass
= NULL
;
1209 char *ncategory
= NULL
;
1210 char *nselector
= NULL
;
1212 CHECK (type
!= NULL
);
1213 CHECK (class != NULL
);
1214 CHECK (category
!= NULL
);
1215 CHECK (selector
!= NULL
);
1219 while (isspace (*s1
))
1226 while (isspace (*s1
))
1229 if ((s1
[0] == '+') || (s1
[0] == '-'))
1232 while (isspace (*s1
))
1240 while (isalnum (*s1
) || (*s1
== '_'))
1244 while (isspace (*s2
))
1250 while (isspace (*s2
))
1253 while (isalnum (*s2
) || (*s2
== '_'))
1258 /* Truncate the class name now that we're not using the open paren. */
1265 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1267 else if (isspace (*s2
))
1269 else if (*s2
== ']')
1278 while (isspace (*s2
))
1285 while (isspace (*s2
))
1293 if (category
!= NULL
)
1294 *category
= ncategory
;
1295 if (selector
!= NULL
)
1296 *selector
= nselector
;
1302 find_methods (struct symtab
*symtab
, char type
,
1303 const char *class, const char *category
,
1304 const char *selector
, struct symbol
**syms
,
1305 unsigned int *nsym
, unsigned int *ndebug
)
1307 struct objfile
*objfile
= NULL
;
1308 struct minimal_symbol
*msymbol
= NULL
;
1309 struct block
*block
= NULL
;
1310 struct symbol
*sym
= NULL
;
1312 char *symname
= NULL
;
1315 char *nclass
= NULL
;
1316 char *ncategory
= NULL
;
1317 char *nselector
= NULL
;
1319 unsigned int csym
= 0;
1320 unsigned int cdebug
= 0;
1322 static char *tmp
= NULL
;
1323 static unsigned int tmplen
= 0;
1325 CHECK (nsym
!= NULL
);
1326 CHECK (ndebug
!= NULL
);
1329 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1331 ALL_MSYMBOLS (objfile
, msymbol
)
1335 if ((msymbol
->type
!= mst_text
) && (msymbol
->type
!= mst_file_text
))
1336 /* Not a function or method. */
1340 if ((SYMBOL_VALUE_ADDRESS (msymbol
) < BLOCK_START (block
)) ||
1341 (SYMBOL_VALUE_ADDRESS (msymbol
) >= BLOCK_END (block
)))
1342 /* Not in the specified symtab. */
1345 symname
= SYMBOL_NATURAL_NAME (msymbol
);
1346 if (symname
== NULL
)
1349 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1350 /* Not a method name. */
1353 while ((strlen (symname
) + 1) >= tmplen
)
1355 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1356 tmp
= xrealloc (tmp
, tmplen
);
1358 strcpy (tmp
, symname
);
1360 if (parse_method (tmp
, &ntype
, &nclass
, &ncategory
, &nselector
) == NULL
)
1363 if ((type
!= '\0') && (ntype
!= type
))
1367 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1370 if ((category
!= NULL
) &&
1371 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1374 if ((selector
!= NULL
) &&
1375 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1378 sym
= find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol
));
1381 const char *newsymname
= SYMBOL_NATURAL_NAME (sym
);
1383 if (strcmp (symname
, newsymname
) == 0)
1385 /* Found a high-level method sym: swap it into the
1386 lower part of sym_arr (below num_debuggable). */
1389 syms
[csym
] = syms
[cdebug
];
1398 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1399 newsymname
, symname
);
1401 syms
[csym
] = (struct symbol
*) msymbol
;
1407 /* Found a non-debuggable method symbol. */
1409 syms
[csym
] = (struct symbol
*) msymbol
;
1420 char *find_imps (struct symtab
*symtab
, struct block
*block
,
1421 char *method
, struct symbol
**syms
,
1422 unsigned int *nsym
, unsigned int *ndebug
)
1426 char *category
= NULL
;
1427 char *selector
= NULL
;
1429 unsigned int csym
= 0;
1430 unsigned int cdebug
= 0;
1432 unsigned int ncsym
= 0;
1433 unsigned int ncdebug
= 0;
1438 CHECK (nsym
!= NULL
);
1439 CHECK (ndebug
!= NULL
);
1446 buf
= (char *) alloca (strlen (method
) + 1);
1447 strcpy (buf
, method
);
1448 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1452 struct symtab
*sym_symtab
= NULL
;
1453 struct symbol
*sym
= NULL
;
1454 struct minimal_symbol
*msym
= NULL
;
1456 strcpy (buf
, method
);
1457 tmp
= parse_selector (buf
, &selector
);
1462 sym
= lookup_symbol (selector
, block
, VAR_NAMESPACE
, 0, &sym_symtab
);
1472 msym
= lookup_minimal_symbol (selector
, 0, 0);
1477 syms
[csym
] = (struct symbol
*)msym
;
1483 find_methods (symtab
, type
, class, category
, selector
,
1484 syms
+ csym
, &ncsym
, &ncdebug
);
1486 find_methods (symtab
, type
, class, category
, selector
,
1487 NULL
, &ncsym
, &ncdebug
);
1489 /* If we didn't find any methods, just return. */
1490 if (ncsym
== 0 && ncdebug
== 0)
1493 /* Take debug symbols from the second batch of symbols and swap them
1494 * with debug symbols from the first batch. Repeat until either the
1495 * second section is out of debug symbols or the first section is
1496 * full of debug symbols. Either way we have all debug symbols
1497 * packed to the beginning of the buffer.
1502 while ((cdebug
< csym
) && (ncdebug
> 0))
1504 struct symbol
*s
= NULL
;
1505 /* First non-debugging symbol. */
1506 unsigned int i
= cdebug
;
1507 /* Last of second batch of debug symbols. */
1508 unsigned int j
= csym
+ ncdebug
- 1;
1514 /* We've moved a symbol from the second debug section to the
1530 return method
+ (tmp
- buf
);
1534 /* Sort debuggable symbols. */
1536 qsort (syms
, cdebug
, sizeof (struct minimal_symbol
*),
1539 /* Sort minimal_symbols. */
1540 if ((csym
- cdebug
) > 1)
1541 qsort (&syms
[cdebug
], csym
- cdebug
,
1542 sizeof (struct minimal_symbol
*), compare_classes
);
1544 /* Terminate the sym_arr list. */
1547 return method
+ (tmp
- buf
);
1551 print_object_command (char *args
, int from_tty
)
1553 struct value
*object
, *function
, *description
;
1554 CORE_ADDR string_addr
, object_addr
;
1558 if (!args
|| !*args
)
1560 "The 'print-object' command requires an argument (an Objective-C object)");
1563 struct expression
*expr
= parse_expression (args
);
1564 register struct cleanup
*old_chain
=
1565 make_cleanup (free_current_contents
, &expr
);
1568 object
= expr
->language_defn
->evaluate_exp (builtin_type_void_data_ptr
,
1569 expr
, &pc
, EVAL_NORMAL
);
1570 do_cleanups (old_chain
);
1573 /* Validate the address for sanity. */
1574 object_addr
= value_as_long (object
);
1575 read_memory (object_addr
, &c
, 1);
1577 function
= find_function_in_inferior ("_NSPrintForDebugger");
1578 if (function
== NULL
)
1579 error ("Unable to locate _NSPrintForDebugger in child process");
1581 description
= call_function_by_hand (function
, 1, &object
);
1583 string_addr
= value_as_long (description
);
1584 if (string_addr
== 0)
1585 error ("object returns null description");
1587 read_memory (string_addr
+ i
++, &c
, 1);
1590 { /* Read and print characters up to EOS. */
1592 printf_filtered ("%c", c
);
1593 read_memory (string_addr
+ i
++, &c
, 1);
1596 printf_filtered("<object returns empty description>");
1597 printf_filtered ("\n");
1600 /* The data structure 'methcalls' is used to detect method calls (thru
1601 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1602 * and ultimately find the method being called.
1605 struct objc_methcall
{
1607 /* Return instance method to be called. */
1608 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1609 /* Start of pc range corresponding to method invocation. */
1611 /* End of pc range corresponding to method invocation. */
1615 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1616 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1617 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1618 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1620 static struct objc_methcall methcalls
[] = {
1621 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1622 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1623 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1624 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1625 { "_objc_getClass", NULL
, 0, 0},
1626 { "_objc_getMetaClass", NULL
, 0, 0}
1629 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1631 /* The following function, "find_objc_msgsend", fills in the data
1632 * structure "objc_msgs" by finding the addresses of each of the
1633 * (currently four) functions that it holds (of which objc_msgSend is
1634 * the first). This must be called each time symbols are loaded, in
1635 * case the functions have moved for some reason.
1639 find_objc_msgsend (void)
1642 for (i
= 0; i
< nmethcalls
; i
++) {
1644 struct minimal_symbol
*func
;
1646 /* Try both with and without underscore. */
1647 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1648 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_')) {
1649 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1652 methcalls
[i
].begin
= 0;
1653 methcalls
[i
].end
= 0;
1657 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1659 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1660 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
1664 /* find_objc_msgcall (replaces pc_off_limits)
1666 * ALL that this function now does is to determine whether the input
1667 * address ("pc") is the address of one of the Objective-C message
1668 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1669 * if so, it returns the address of the method that will be called.
1671 * The old function "pc_off_limits" used to do a lot of other things
1672 * in addition, such as detecting shared library jump stubs and
1673 * returning the address of the shlib function that would be called.
1674 * That functionality has been moved into the SKIP_TRAMPOLINE_CODE and
1675 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1676 * dependent modules.
1679 struct objc_submethod_helper_data
{
1680 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1686 find_objc_msgcall_submethod_helper (void * arg
)
1688 struct objc_submethod_helper_data
*s
=
1689 (struct objc_submethod_helper_data
*) arg
;
1691 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1698 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1702 struct objc_submethod_helper_data s
;
1708 if (catch_errors (find_objc_msgcall_submethod_helper
,
1710 "Unable to determine target of Objective-C method call (ignoring):\n",
1711 RETURN_MASK_ALL
) == 0)
1718 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1722 find_objc_msgsend ();
1728 for (i
= 0; i
< nmethcalls
; i
++)
1729 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1731 if (methcalls
[i
].stop_at
!= NULL
)
1732 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1742 _initialize_objc_language (void)
1744 add_language (&objc_language_defn
);
1745 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1746 "All Objective-C selectors, or those matching REGEXP.");
1747 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1748 "All Objective-C classes, or those matching REGEXP.");
1749 add_com ("print-object", class_vars
, print_object_command
,
1750 "Ask an Objective-C object to print itself.");
1751 add_com_alias ("po", "print-object", class_vars
, 1);
1754 #if defined (__powerpc__) || defined (__ppc__)
1755 static unsigned long FETCH_ARGUMENT (int i
)
1757 return read_register (3 + i
);
1759 #elif defined (__i386__)
1760 static unsigned long FETCH_ARGUMENT (int i
)
1762 CORE_ADDR stack
= read_register (SP_REGNUM
);
1763 return read_memory_unsigned_integer (stack
+ (4 * (i
+ 1)), 4);
1765 #elif defined (__sparc__)
1766 static unsigned long FETCH_ARGUMENT (int i
)
1768 return read_register (O0_REGNUM
+ i
);
1770 #elif defined (__hppa__) || defined (__hppa)
1771 static unsigned long FETCH_ARGUMENT (int i
)
1773 return read_register (R0_REGNUM
+ 26 - i
);
1776 #error unknown architecture
1779 #if defined (__hppa__) || defined (__hppa)
1780 static CORE_ADDR
CONVERT_FUNCPTR (CORE_ADDR pc
)
1783 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, 4);
1788 static CORE_ADDR
CONVERT_FUNCPTR (CORE_ADDR pc
)
1795 read_objc_method (CORE_ADDR addr
, struct objc_method
*method
)
1797 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4);
1798 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4);
1799 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4);
1803 unsigned long read_objc_methlist_nmethods (CORE_ADDR addr
)
1805 return read_memory_unsigned_integer (addr
+ 4, 4);
1809 read_objc_methlist_method (CORE_ADDR addr
, unsigned long num
,
1810 struct objc_method
*method
)
1812 CHECK_FATAL (num
< read_objc_methlist_nmethods (addr
));
1813 read_objc_method (addr
+ 8 + (12 * num
), method
);
1817 read_objc_object (CORE_ADDR addr
, struct objc_object
*object
)
1819 object
->isa
= read_memory_unsigned_integer (addr
, 4);
1823 read_objc_super (CORE_ADDR addr
, struct objc_super
*super
)
1825 super
->receiver
= read_memory_unsigned_integer (addr
, 4);
1826 super
->class = read_memory_unsigned_integer (addr
+ 4, 4);
1830 read_objc_class (CORE_ADDR addr
, struct objc_class
*class)
1832 class->isa
= read_memory_unsigned_integer (addr
, 4);
1833 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4);
1834 class->name
= read_memory_unsigned_integer (addr
+ 8, 4);
1835 class->version
= read_memory_unsigned_integer (addr
+ 12, 4);
1836 class->info
= read_memory_unsigned_integer (addr
+ 16, 4);
1837 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4);
1838 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4);
1839 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4);
1840 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4);
1841 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4);
1845 find_implementation_from_class (CORE_ADDR
class, CORE_ADDR sel
)
1847 CORE_ADDR subclass
= class;
1849 while (subclass
!= 0)
1852 struct objc_class class_str
;
1853 unsigned mlistnum
= 0;
1855 read_objc_class (subclass
, &class_str
);
1860 unsigned long nmethods
;
1863 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1868 nmethods
= read_objc_methlist_nmethods (mlist
);
1870 for (i
= 0; i
< nmethods
; i
++)
1872 struct objc_method meth_str
;
1873 read_objc_methlist_method (mlist
, i
, &meth_str
);
1877 "checking method 0x%lx against selector 0x%lx\n",
1878 meth_str
.name
, sel
);
1881 if (meth_str
.name
== sel
)
1882 return CONVERT_FUNCPTR (meth_str
.imp
);
1886 subclass
= class_str
.super_class
;
1893 find_implementation (CORE_ADDR object
, CORE_ADDR sel
)
1895 struct objc_object ostr
;
1899 read_objc_object (object
, &ostr
);
1903 return find_implementation_from_class (ostr
.isa
, sel
);
1907 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1913 object
= FETCH_ARGUMENT (0);
1914 sel
= FETCH_ARGUMENT (1);
1916 res
= find_implementation (object
, sel
);
1925 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1931 object
= FETCH_ARGUMENT (1);
1932 sel
= FETCH_ARGUMENT (2);
1934 res
= find_implementation (object
, sel
);
1943 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1945 struct objc_super sstr
;
1951 super
= FETCH_ARGUMENT (0);
1952 sel
= FETCH_ARGUMENT (1);
1954 read_objc_super (super
, &sstr
);
1955 if (sstr
.class == 0)
1958 res
= find_implementation_from_class (sstr
.class, sel
);
1967 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1969 struct objc_super sstr
;
1975 super
= FETCH_ARGUMENT (1);
1976 sel
= FETCH_ARGUMENT (2);
1978 read_objc_super (super
, &sstr
);
1979 if (sstr
.class == 0)
1982 res
= find_implementation_from_class (sstr
.class, sel
);