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 if (!(sym
= lookup_struct_typedef("NSString", 0, 1)) &&
203 !(sym
= lookup_struct_typedef("NXString", 0, 1)))
204 type
= lookup_pointer_type(builtin_type_void
);
206 type
= lookup_pointer_type(SYMBOL_TYPE (sym
));
208 stringValue
[2] = value_string(ptr
, len
);
209 stringValue
[2] = value_coerce_array(stringValue
[2]);
210 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
211 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
213 function
= find_function_in_inferior("_NSNewStringFromCString");
214 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
216 else if (lookup_minimal_symbol("istr", 0, 0))
218 function
= find_function_in_inferior("istr");
219 nsstringValue
= call_function_by_hand(function
, 1, &stringValue
[2]);
221 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
223 function
= find_function_in_inferior("+[NSString stringWithCString:]");
224 stringValue
[0] = value_from_longest
225 (builtin_type_long
, lookup_objc_class ("NSString"));
226 stringValue
[1] = value_from_longest
227 (builtin_type_long
, lookup_child_selector ("stringWithCString:"));
228 nsstringValue
= call_function_by_hand(function
, 3, &stringValue
[0]);
231 error ("NSString: internal error -- no way to create new NSString");
233 VALUE_TYPE(nsstringValue
) = type
;
234 return nsstringValue
;
237 /* Objective-C name demangling. */
240 objc_demangle (const char *mangled
, int options
)
242 char *demangled
, *cp
;
244 if (mangled
[0] == '_' &&
245 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
248 cp
= demangled
= xmalloc(strlen(mangled
) + 2);
250 if (mangled
[1] == 'i')
251 *cp
++ = '-'; /* for instance method */
253 *cp
++ = '+'; /* for class method */
255 *cp
++ = '['; /* opening left brace */
256 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
258 while (*cp
&& *cp
== '_')
259 cp
++; /* skip any initial underbars in class name */
261 cp
= strchr(cp
, '_');
262 if (!cp
) /* find first non-initial underbar */
264 xfree(demangled
); /* not mangled name */
267 if (cp
[1] == '_') { /* easy case: no category name */
268 *cp
++ = ' '; /* replace two '_' with one ' ' */
269 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
272 *cp
++ = '('; /* less easy case: category name */
273 cp
= strchr(cp
, '_');
276 xfree(demangled
); /* not mangled name */
280 *cp
++ = ' '; /* overwriting 1st char of method name... */
281 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
284 while (*cp
&& *cp
== '_')
285 cp
++; /* skip any initial underbars in method name */
289 *cp
= ':'; /* replace remaining '_' with ':' */
291 *cp
++ = ']'; /* closing right brace */
292 *cp
++ = 0; /* string terminator */
296 return NULL
; /* Not an objc mangled name. */
299 /* Print the character C on STREAM as part of the contents of a
300 literal string whose delimiter is QUOTER. Note that that format
301 for printing characters and strings is language specific. */
304 objc_emit_char (register int c
, struct ui_file
*stream
, int quoter
)
307 c
&= 0xFF; /* Avoid sign bit follies. */
309 if (PRINT_LITERAL_FORM (c
))
311 if (c
== '\\' || c
== quoter
)
313 fputs_filtered ("\\", stream
);
315 fprintf_filtered (stream
, "%c", c
);
322 fputs_filtered ("\\n", stream
);
325 fputs_filtered ("\\b", stream
);
328 fputs_filtered ("\\t", stream
);
331 fputs_filtered ("\\f", stream
);
334 fputs_filtered ("\\r", stream
);
337 fputs_filtered ("\\e", stream
);
340 fputs_filtered ("\\a", stream
);
343 fprintf_filtered (stream
, "\\%.3o", (unsigned int) c
);
350 objc_printchar (int c
, struct ui_file
*stream
)
352 fputs_filtered ("'", stream
);
353 objc_emit_char (c
, stream
, '\'');
354 fputs_filtered ("'", stream
);
357 /* Print the character string STRING, printing at most LENGTH
358 characters. Printing stops early if the number hits print_max;
359 repeat counts are printed as appropriate. Print ellipses at the
360 end if we had to stop before printing LENGTH characters, or if
364 objc_printstr (struct ui_file
*stream
, char *string
,
365 unsigned int length
, int width
, int force_ellipses
)
367 register unsigned int i
;
368 unsigned int things_printed
= 0;
371 extern int inspect_it
;
372 extern int repeat_count_threshold
;
373 extern int print_max
;
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
, ".*]");
893 if (0 != (val
= re_comp (myregexp
)))
894 error ("Invalid regexp (%s): %s", val
, regexp
);
896 /* First time thru is JUST to get max length and count. */
897 ALL_MSYMBOLS (objfile
, msymbol
)
900 name
= SYMBOL_NATURAL_NAME (msymbol
);
902 (name
[0] == '-' || name
[0] == '+') &&
903 name
[1] == '[') /* Got a method name. */
905 /* Filter for class/instance methods. */
906 if (plusminus
&& name
[0] != plusminus
)
908 /* Find selector part. */
909 name
= (char *) strchr(name
+2, ' ');
910 if (regexp
== NULL
|| re_exec(++name
) != 0)
912 char *mystart
= name
;
913 char *myend
= (char *) strchr(mystart
, ']');
915 if (myend
&& (myend
- mystart
> maxlen
))
916 maxlen
= myend
- mystart
; /* Get longest selector. */
923 printf_filtered ("Selectors matching \"%s\":\n\n",
924 regexp
? regexp
: "*");
926 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
928 ALL_MSYMBOLS (objfile
, msymbol
)
931 name
= SYMBOL_NATURAL_NAME (msymbol
);
933 (name
[0] == '-' || name
[0] == '+') &&
934 name
[1] == '[') /* Got a method name. */
936 /* Filter for class/instance methods. */
937 if (plusminus
&& name
[0] != plusminus
)
939 /* Find selector part. */
940 name
= (char *) strchr(name
+2, ' ');
941 if (regexp
== NULL
|| re_exec(++name
) != 0)
942 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
946 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
948 /* Prevent compare on first iteration. */
950 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
955 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
956 name
= strchr (name
, ' ') + 1;
957 if (p
[0] && specialcmp(name
, p
) == 0)
958 continue; /* Seen this one already (not unique). */
960 /* Copy selector part. */
961 while (*name
&& *name
!= ']')
964 /* Print in columns. */
965 puts_filtered_tabular(asel
, maxlen
+ 1, 0);
970 printf_filtered ("No selectors matching \"%s\"\n", regexp
? regexp
: "*");
974 * Function: compare_classes (const void *, const void *)
976 * Comparison function for use with qsort. Arguments are symbols or
977 * msymbols Compares class part of objc method name alphabetically.
981 compare_classes (const void *a
, const void *b
)
985 aname
= SYMBOL_PRINT_NAME (*(struct symbol
**) a
);
986 bname
= SYMBOL_PRINT_NAME (*(struct symbol
**) b
);
987 if (aname
== NULL
|| bname
== NULL
)
988 error ("internal: compare_classes(1)");
990 return specialcmp (aname
+1, bname
+1);
994 * Function: classes_info(regexp, from_tty)
996 * Implements the "info classes" command for objective c classes.
997 * Lists all objective c classes that match the optional regexp.
998 * Works by grepping thru the list of objective c methods. List will
999 * be sorted and uniqued (since one class may have many methods).
1000 * BUGS: will not list a class that has no methods.
1004 classes_info (char *regexp
, int from_tty
)
1006 struct objfile
*objfile
;
1007 struct minimal_symbol
*msymbol
;
1013 char myregexp
[2048];
1015 struct symbol
**sym_arr
;
1018 strcpy(myregexp
, ".* "); /* Null input: match all objc classes. */
1021 strcpy(myregexp
, regexp
);
1022 if (myregexp
[strlen(myregexp
) - 1] == '$')
1023 /* In the method name, the end of the class name is marked by ' '. */
1024 myregexp
[strlen(myregexp
) - 1] = ' ';
1026 strcat(myregexp
, ".* ");
1030 if (0 != (val
= re_comp (myregexp
)))
1031 error ("Invalid regexp (%s): %s", val
, regexp
);
1033 /* First time thru is JUST to get max length and count. */
1034 ALL_MSYMBOLS (objfile
, msymbol
)
1037 name
= SYMBOL_NATURAL_NAME (msymbol
);
1039 (name
[0] == '-' || name
[0] == '+') &&
1040 name
[1] == '[') /* Got a method name. */
1041 if (regexp
== NULL
|| re_exec(name
+2) != 0)
1043 /* Compute length of classname part. */
1044 char *mystart
= name
+ 2;
1045 char *myend
= (char *) strchr(mystart
, ' ');
1047 if (myend
&& (myend
- mystart
> maxlen
))
1048 maxlen
= myend
- mystart
;
1054 printf_filtered ("Classes matching \"%s\":\n\n",
1055 regexp
? regexp
: "*");
1056 sym_arr
= alloca (matches
* sizeof (struct symbol
*));
1058 ALL_MSYMBOLS (objfile
, msymbol
)
1061 name
= SYMBOL_NATURAL_NAME (msymbol
);
1063 (name
[0] == '-' || name
[0] == '+') &&
1064 name
[1] == '[') /* Got a method name. */
1065 if (regexp
== NULL
|| re_exec(name
+2) != 0)
1066 sym_arr
[matches
++] = (struct symbol
*) msymbol
;
1069 qsort (sym_arr
, matches
, sizeof (struct minimal_symbol
*),
1071 /* Prevent compare on first iteration. */
1073 for (ix
= 0; ix
< matches
; ix
++) /* Now do the output. */
1078 name
= SYMBOL_NATURAL_NAME (sym_arr
[ix
]);
1080 if (p
[0] && specialcmp(name
, p
) == 0)
1081 continue; /* Seen this one already (not unique). */
1083 /* Copy class part of method name. */
1084 while (*name
&& *name
!= ' ')
1087 /* Print in columns. */
1088 puts_filtered_tabular(aclass
, maxlen
+ 1, 0);
1093 printf_filtered ("No classes matching \"%s\"\n", regexp
? regexp
: "*");
1097 * Function: find_imps (char *selector, struct symbol **sym_arr)
1099 * Input: a string representing a selector
1100 * a pointer to an array of symbol pointers
1101 * possibly a pointer to a symbol found by the caller.
1103 * Output: number of methods that implement that selector. Side
1104 * effects: The array of symbol pointers is filled with matching syms.
1106 * By analogy with function "find_methods" (symtab.c), builds a list
1107 * of symbols matching the ambiguous input, so that "decode_line_2"
1108 * (symtab.c) can list them and ask the user to choose one or more.
1109 * In this case the matches are objective c methods
1110 * ("implementations") matching an objective c selector.
1112 * Note that it is possible for a normal (c-style) function to have
1113 * the same name as an objective c selector. To prevent the selector
1114 * from eclipsing the function, we allow the caller (decode_line_1) to
1115 * search for such a function first, and if it finds one, pass it in
1116 * to us. We will then integrate it into the list. We also search
1117 * for one here, among the minsyms.
1119 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1120 * into two parts: debuggable (struct symbol) syms, and
1121 * non_debuggable (struct minimal_symbol) syms. The debuggable
1122 * ones will come first, before NUM_DEBUGGABLE (which will thus
1123 * be the index of the first non-debuggable one).
1127 * Function: total_number_of_imps (char *selector);
1129 * Input: a string representing a selector
1130 * Output: number of methods that implement that selector.
1132 * By analogy with function "total_number_of_methods", this allows
1133 * decode_line_1 (symtab.c) to detect if there are objective c methods
1134 * matching the input, and to allocate an array of pointers to them
1135 * which can be manipulated by "decode_line_2" (also in symtab.c).
1139 parse_selector (char *method
, char **selector
)
1143 int found_quote
= 0;
1145 char *nselector
= NULL
;
1147 CHECK (selector
!= NULL
);
1151 while (isspace (*s1
))
1158 while (isspace (*s1
))
1165 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1167 else if (isspace (*s2
))
1169 else if ((*s2
== '\0') || (*s2
== '\''))
1177 while (isspace (*s2
))
1183 while (isspace (*s2
))
1187 if (selector
!= NULL
)
1188 *selector
= nselector
;
1194 parse_method (char *method
, char *type
, char **class,
1195 char **category
, char **selector
)
1199 int found_quote
= 0;
1202 char *nclass
= NULL
;
1203 char *ncategory
= NULL
;
1204 char *nselector
= NULL
;
1206 CHECK (type
!= NULL
);
1207 CHECK (class != NULL
);
1208 CHECK (category
!= NULL
);
1209 CHECK (selector
!= NULL
);
1213 while (isspace (*s1
))
1220 while (isspace (*s1
))
1223 if ((s1
[0] == '+') || (s1
[0] == '-'))
1226 while (isspace (*s1
))
1234 while (isalnum (*s1
) || (*s1
== '_'))
1238 while (isspace (*s2
))
1244 while (isspace (*s2
))
1247 while (isalnum (*s2
) || (*s2
== '_'))
1252 /* Truncate the class name now that we're not using the open paren. */
1259 if (isalnum (*s2
) || (*s2
== '_') || (*s2
== ':'))
1261 else if (isspace (*s2
))
1263 else if (*s2
== ']')
1272 while (isspace (*s2
))
1279 while (isspace (*s2
))
1287 if (category
!= NULL
)
1288 *category
= ncategory
;
1289 if (selector
!= NULL
)
1290 *selector
= nselector
;
1296 find_methods (struct symtab
*symtab
, char type
,
1297 const char *class, const char *category
,
1298 const char *selector
, struct symbol
**syms
,
1299 unsigned int *nsym
, unsigned int *ndebug
)
1301 struct objfile
*objfile
= NULL
;
1302 struct minimal_symbol
*msymbol
= NULL
;
1303 struct block
*block
= NULL
;
1304 struct symbol
*sym
= NULL
;
1306 char *symname
= NULL
;
1309 char *nclass
= NULL
;
1310 char *ncategory
= NULL
;
1311 char *nselector
= NULL
;
1313 unsigned int csym
= 0;
1314 unsigned int cdebug
= 0;
1316 static char *tmp
= NULL
;
1317 static unsigned int tmplen
= 0;
1319 CHECK (nsym
!= NULL
);
1320 CHECK (ndebug
!= NULL
);
1323 block
= BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab
), STATIC_BLOCK
);
1325 ALL_MSYMBOLS (objfile
, msymbol
)
1329 if ((msymbol
->type
!= mst_text
) && (msymbol
->type
!= mst_file_text
))
1330 /* Not a function or method. */
1334 if ((SYMBOL_VALUE_ADDRESS (msymbol
) < BLOCK_START (block
)) ||
1335 (SYMBOL_VALUE_ADDRESS (msymbol
) >= BLOCK_END (block
)))
1336 /* Not in the specified symtab. */
1339 symname
= SYMBOL_NATURAL_NAME (msymbol
);
1340 if (symname
== NULL
)
1343 if ((symname
[0] != '-' && symname
[0] != '+') || (symname
[1] != '['))
1344 /* Not a method name. */
1347 while ((strlen (symname
) + 1) >= tmplen
)
1349 tmplen
= (tmplen
== 0) ? 1024 : tmplen
* 2;
1350 tmp
= xrealloc (tmp
, tmplen
);
1352 strcpy (tmp
, symname
);
1354 if (parse_method (tmp
, &ntype
, &nclass
, &ncategory
, &nselector
) == NULL
)
1357 if ((type
!= '\0') && (ntype
!= type
))
1361 && ((nclass
== NULL
) || (strcmp (class, nclass
) != 0)))
1364 if ((category
!= NULL
) &&
1365 ((ncategory
== NULL
) || (strcmp (category
, ncategory
) != 0)))
1368 if ((selector
!= NULL
) &&
1369 ((nselector
== NULL
) || (strcmp (selector
, nselector
) != 0)))
1372 sym
= find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol
));
1375 const char *newsymname
= SYMBOL_NATURAL_NAME (sym
);
1377 if (strcmp (symname
, newsymname
) == 0)
1379 /* Found a high-level method sym: swap it into the
1380 lower part of sym_arr (below num_debuggable). */
1383 syms
[csym
] = syms
[cdebug
];
1392 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1393 newsymname
, symname
);
1395 syms
[csym
] = (struct symbol
*) msymbol
;
1401 /* Found a non-debuggable method symbol. */
1403 syms
[csym
] = (struct symbol
*) msymbol
;
1414 char *find_imps (struct symtab
*symtab
, struct block
*block
,
1415 char *method
, struct symbol
**syms
,
1416 unsigned int *nsym
, unsigned int *ndebug
)
1420 char *category
= NULL
;
1421 char *selector
= NULL
;
1423 unsigned int csym
= 0;
1424 unsigned int cdebug
= 0;
1426 unsigned int ncsym
= 0;
1427 unsigned int ncdebug
= 0;
1432 CHECK (nsym
!= NULL
);
1433 CHECK (ndebug
!= NULL
);
1440 buf
= (char *) alloca (strlen (method
) + 1);
1441 strcpy (buf
, method
);
1442 tmp
= parse_method (buf
, &type
, &class, &category
, &selector
);
1446 struct symtab
*sym_symtab
= NULL
;
1447 struct symbol
*sym
= NULL
;
1448 struct minimal_symbol
*msym
= NULL
;
1450 strcpy (buf
, method
);
1451 tmp
= parse_selector (buf
, &selector
);
1456 sym
= lookup_symbol (selector
, block
, VAR_NAMESPACE
, 0, &sym_symtab
);
1466 msym
= lookup_minimal_symbol (selector
, 0, 0);
1471 syms
[csym
] = (struct symbol
*)msym
;
1477 find_methods (symtab
, type
, class, category
, selector
,
1478 syms
+ csym
, &ncsym
, &ncdebug
);
1480 find_methods (symtab
, type
, class, category
, selector
,
1481 NULL
, &ncsym
, &ncdebug
);
1483 /* If we didn't find any methods, just return. */
1484 if (ncsym
== 0 && ncdebug
== 0)
1487 /* Take debug symbols from the second batch of symbols and swap them
1488 * with debug symbols from the first batch. Repeat until either the
1489 * second section is out of debug symbols or the first section is
1490 * full of debug symbols. Either way we have all debug symbols
1491 * packed to the beginning of the buffer.
1496 while ((cdebug
< csym
) && (ncdebug
> 0))
1498 struct symbol
*s
= NULL
;
1499 /* First non-debugging symbol. */
1500 unsigned int i
= cdebug
;
1501 /* Last of second batch of debug symbols. */
1502 unsigned int j
= csym
+ ncdebug
- 1;
1508 /* We've moved a symbol from the second debug section to the
1524 return method
+ (tmp
- buf
);
1528 /* Sort debuggable symbols. */
1530 qsort (syms
, cdebug
, sizeof (struct minimal_symbol
*),
1533 /* Sort minimal_symbols. */
1534 if ((csym
- cdebug
) > 1)
1535 qsort (&syms
[cdebug
], csym
- cdebug
,
1536 sizeof (struct minimal_symbol
*), compare_classes
);
1538 /* Terminate the sym_arr list. */
1541 return method
+ (tmp
- buf
);
1545 print_object_command (char *args
, int from_tty
)
1547 struct value
*object
, *function
, *description
;
1548 CORE_ADDR string_addr
, object_addr
;
1552 if (!args
|| !*args
)
1554 "The 'print-object' command requires an argument (an Objective-C object)");
1557 struct expression
*expr
= parse_expression (args
);
1558 register struct cleanup
*old_chain
=
1559 make_cleanup (free_current_contents
, &expr
);
1562 object
= expr
->language_defn
->evaluate_exp (builtin_type_void_data_ptr
,
1563 expr
, &pc
, EVAL_NORMAL
);
1564 do_cleanups (old_chain
);
1567 /* Validate the address for sanity. */
1568 object_addr
= value_as_long (object
);
1569 read_memory (object_addr
, &c
, 1);
1571 function
= find_function_in_inferior ("_NSPrintForDebugger");
1572 if (function
== NULL
)
1573 error ("Unable to locate _NSPrintForDebugger in child process");
1575 description
= call_function_by_hand (function
, 1, &object
);
1577 string_addr
= value_as_long (description
);
1578 if (string_addr
== 0)
1579 error ("object returns null description");
1581 read_memory (string_addr
+ i
++, &c
, 1);
1584 { /* Read and print characters up to EOS. */
1586 printf_filtered ("%c", c
);
1587 read_memory (string_addr
+ i
++, &c
, 1);
1590 printf_filtered("<object returns empty description>");
1591 printf_filtered ("\n");
1594 /* The data structure 'methcalls' is used to detect method calls (thru
1595 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1596 * and ultimately find the method being called.
1599 struct objc_methcall
{
1601 /* Return instance method to be called. */
1602 int (*stop_at
) (CORE_ADDR
, CORE_ADDR
*);
1603 /* Start of pc range corresponding to method invocation. */
1605 /* End of pc range corresponding to method invocation. */
1609 static int resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1610 static int resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1611 static int resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1612 static int resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
);
1614 static struct objc_methcall methcalls
[] = {
1615 { "_objc_msgSend", resolve_msgsend
, 0, 0},
1616 { "_objc_msgSend_stret", resolve_msgsend_stret
, 0, 0},
1617 { "_objc_msgSendSuper", resolve_msgsend_super
, 0, 0},
1618 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret
, 0, 0},
1619 { "_objc_getClass", NULL
, 0, 0},
1620 { "_objc_getMetaClass", NULL
, 0, 0}
1623 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1625 /* The following function, "find_objc_msgsend", fills in the data
1626 * structure "objc_msgs" by finding the addresses of each of the
1627 * (currently four) functions that it holds (of which objc_msgSend is
1628 * the first). This must be called each time symbols are loaded, in
1629 * case the functions have moved for some reason.
1633 find_objc_msgsend (void)
1636 for (i
= 0; i
< nmethcalls
; i
++) {
1638 struct minimal_symbol
*func
;
1640 /* Try both with and without underscore. */
1641 func
= lookup_minimal_symbol (methcalls
[i
].name
, NULL
, NULL
);
1642 if ((func
== NULL
) && (methcalls
[i
].name
[0] == '_')) {
1643 func
= lookup_minimal_symbol (methcalls
[i
].name
+ 1, NULL
, NULL
);
1646 methcalls
[i
].begin
= 0;
1647 methcalls
[i
].end
= 0;
1651 methcalls
[i
].begin
= SYMBOL_VALUE_ADDRESS (func
);
1653 methcalls
[i
].end
= SYMBOL_VALUE_ADDRESS (++func
);
1654 } while (methcalls
[i
].begin
== methcalls
[i
].end
);
1658 /* find_objc_msgcall (replaces pc_off_limits)
1660 * ALL that this function now does is to determine whether the input
1661 * address ("pc") is the address of one of the Objective-C message
1662 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1663 * if so, it returns the address of the method that will be called.
1665 * The old function "pc_off_limits" used to do a lot of other things
1666 * in addition, such as detecting shared library jump stubs and
1667 * returning the address of the shlib function that would be called.
1668 * That functionality has been moved into the SKIP_TRAMPOLINE_CODE and
1669 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1670 * dependent modules.
1673 struct objc_submethod_helper_data
{
1674 int (*f
) (CORE_ADDR
, CORE_ADDR
*);
1680 find_objc_msgcall_submethod_helper (void * arg
)
1682 struct objc_submethod_helper_data
*s
=
1683 (struct objc_submethod_helper_data
*) arg
;
1685 if (s
->f (s
->pc
, s
->new_pc
) == 0)
1692 find_objc_msgcall_submethod (int (*f
) (CORE_ADDR
, CORE_ADDR
*),
1696 struct objc_submethod_helper_data s
;
1702 if (catch_errors (find_objc_msgcall_submethod_helper
,
1704 "Unable to determine target of Objective-C method call (ignoring):\n",
1705 RETURN_MASK_ALL
) == 0)
1712 find_objc_msgcall (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1716 find_objc_msgsend ();
1717 if (new_pc
!= NULL
) { *new_pc
= 0; }
1719 for (i
= 0; i
< nmethcalls
; i
++)
1720 if ((pc
>= methcalls
[i
].begin
) && (pc
< methcalls
[i
].end
))
1722 if (methcalls
[i
].stop_at
!= NULL
)
1723 return find_objc_msgcall_submethod (methcalls
[i
].stop_at
,
1733 _initialize_objc_language (void)
1735 add_language (&objc_language_defn
);
1736 add_info ("selectors", selectors_info
, /* INFO SELECTORS command. */
1737 "All Objective-C selectors, or those matching REGEXP.");
1738 add_info ("classes", classes_info
, /* INFO CLASSES command. */
1739 "All Objective-C classes, or those matching REGEXP.");
1740 add_com ("print-object", class_vars
, print_object_command
,
1741 "Ask an Objective-C object to print itself.");
1742 add_com_alias ("po", "print-object", class_vars
, 1);
1745 #if defined (__powerpc__) || defined (__ppc__)
1746 static unsigned long FETCH_ARGUMENT (int i
)
1748 return read_register (3 + i
);
1750 #elif defined (__i386__)
1751 static unsigned long FETCH_ARGUMENT (int i
)
1753 CORE_ADDR stack
= read_register (SP_REGNUM
);
1754 return read_memory_unsigned_integer (stack
+ (4 * (i
+ 1)), 4);
1756 #elif defined (__sparc__)
1757 static unsigned long FETCH_ARGUMENT (int i
)
1759 return read_register (O0_REGNUM
+ i
);
1761 #elif defined (__hppa__) || defined (__hppa)
1762 static unsigned long FETCH_ARGUMENT (int i
)
1764 return read_register (R0_REGNUM
+ 26 - i
);
1767 #error unknown architecture
1770 #if defined (__hppa__) || defined (__hppa)
1771 static CORE_ADDR
CONVERT_FUNCPTR (CORE_ADDR pc
)
1774 pc
= (CORE_ADDR
) read_memory_integer (pc
& ~0x3, 4);
1779 static CORE_ADDR
CONVERT_FUNCPTR (CORE_ADDR pc
)
1786 read_objc_method (CORE_ADDR addr
, struct objc_method
*method
)
1788 method
->name
= read_memory_unsigned_integer (addr
+ 0, 4);
1789 method
->types
= read_memory_unsigned_integer (addr
+ 4, 4);
1790 method
->imp
= read_memory_unsigned_integer (addr
+ 8, 4);
1794 unsigned long read_objc_methlist_nmethods (CORE_ADDR addr
)
1796 return read_memory_unsigned_integer (addr
+ 4, 4);
1800 read_objc_methlist_method (CORE_ADDR addr
, unsigned long num
,
1801 struct objc_method
*method
)
1803 CHECK_FATAL (num
< read_objc_methlist_nmethods (addr
));
1804 read_objc_method (addr
+ 8 + (12 * num
), method
);
1808 read_objc_object (CORE_ADDR addr
, struct objc_object
*object
)
1810 object
->isa
= read_memory_unsigned_integer (addr
, 4);
1814 read_objc_super (CORE_ADDR addr
, struct objc_super
*super
)
1816 super
->receiver
= read_memory_unsigned_integer (addr
, 4);
1817 super
->class = read_memory_unsigned_integer (addr
+ 4, 4);
1821 read_objc_class (CORE_ADDR addr
, struct objc_class
*class)
1823 class->isa
= read_memory_unsigned_integer (addr
, 4);
1824 class->super_class
= read_memory_unsigned_integer (addr
+ 4, 4);
1825 class->name
= read_memory_unsigned_integer (addr
+ 8, 4);
1826 class->version
= read_memory_unsigned_integer (addr
+ 12, 4);
1827 class->info
= read_memory_unsigned_integer (addr
+ 16, 4);
1828 class->instance_size
= read_memory_unsigned_integer (addr
+ 18, 4);
1829 class->ivars
= read_memory_unsigned_integer (addr
+ 24, 4);
1830 class->methods
= read_memory_unsigned_integer (addr
+ 28, 4);
1831 class->cache
= read_memory_unsigned_integer (addr
+ 32, 4);
1832 class->protocols
= read_memory_unsigned_integer (addr
+ 36, 4);
1836 find_implementation_from_class (CORE_ADDR
class, CORE_ADDR sel
)
1838 CORE_ADDR subclass
= class;
1840 while (subclass
!= 0)
1843 struct objc_class class_str
;
1844 unsigned mlistnum
= 0;
1846 read_objc_class (subclass
, &class_str
);
1851 unsigned long nmethods
;
1854 mlist
= read_memory_unsigned_integer (class_str
.methods
+
1859 nmethods
= read_objc_methlist_nmethods (mlist
);
1861 for (i
= 0; i
< nmethods
; i
++)
1863 struct objc_method meth_str
;
1864 read_objc_methlist_method (mlist
, i
, &meth_str
);
1868 "checking method 0x%lx against selector 0x%lx\n",
1869 meth_str
.name
, sel
);
1872 if (meth_str
.name
== sel
)
1873 return CONVERT_FUNCPTR (meth_str
.imp
);
1877 subclass
= class_str
.super_class
;
1884 find_implementation (CORE_ADDR object
, CORE_ADDR sel
)
1886 struct objc_object ostr
;
1890 read_objc_object (object
, &ostr
);
1894 return find_implementation_from_class (ostr
.isa
, sel
);
1898 resolve_msgsend (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1904 object
= FETCH_ARGUMENT (0);
1905 sel
= FETCH_ARGUMENT (1);
1907 res
= find_implementation (object
, sel
);
1916 resolve_msgsend_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1922 object
= FETCH_ARGUMENT (1);
1923 sel
= FETCH_ARGUMENT (2);
1925 res
= find_implementation (object
, sel
);
1934 resolve_msgsend_super (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1936 struct objc_super sstr
;
1942 super
= FETCH_ARGUMENT (0);
1943 sel
= FETCH_ARGUMENT (1);
1945 read_objc_super (super
, &sstr
);
1946 if (sstr
.class == 0)
1949 res
= find_implementation_from_class (sstr
.class, sel
);
1958 resolve_msgsend_super_stret (CORE_ADDR pc
, CORE_ADDR
*new_pc
)
1960 struct objc_super sstr
;
1966 super
= FETCH_ARGUMENT (1);
1967 sel
= FETCH_ARGUMENT (2);
1969 read_objc_super (super
, &sstr
);
1970 if (sstr
.class == 0)
1973 res
= find_implementation_from_class (sstr
.class, sel
);