Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / objc-lang.c
CommitLineData
5796c8dc
SS
1/* Objective-C language support routines for GDB, the GNU debugger.
2
ef5ccd6c 3 Copyright (C) 2002-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 Contributed by Apple Computer, Inc.
6 Written by Michael Snyder.
7
8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
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.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22
23#include "defs.h"
24#include "symtab.h"
25#include "gdbtypes.h"
26#include "expression.h"
27#include "parser-defs.h"
28#include "language.h"
29#include "c-lang.h"
30#include "objc-lang.h"
31#include "exceptions.h"
32#include "complaints.h"
33#include "value.h"
34#include "symfile.h"
35#include "objfiles.h"
36#include "gdb_string.h" /* for strchr */
37#include "target.h" /* for target_has_execution */
38#include "gdbcore.h"
39#include "gdbcmd.h"
40#include "frame.h"
41#include "gdb_regex.h"
42#include "regcache.h"
43#include "block.h"
44#include "infcall.h"
45#include "valprint.h"
46#include "gdb_assert.h"
ef5ccd6c 47#include "cli/cli-utils.h"
5796c8dc
SS
48
49#include <ctype.h>
50
51struct objc_object {
52 CORE_ADDR isa;
53};
54
55struct objc_class {
56 CORE_ADDR isa;
57 CORE_ADDR super_class;
58 CORE_ADDR name;
59 long version;
60 long info;
61 long instance_size;
62 CORE_ADDR ivars;
63 CORE_ADDR methods;
64 CORE_ADDR cache;
65 CORE_ADDR protocols;
66};
67
68struct objc_super {
69 CORE_ADDR receiver;
70 CORE_ADDR class;
71};
72
73struct objc_method {
74 CORE_ADDR name;
75 CORE_ADDR types;
76 CORE_ADDR imp;
77};
78
79static const struct objfile_data *objc_objfile_data;
80
81/* Lookup a structure type named "struct NAME", visible in lexical
82 block BLOCK. If NOERR is nonzero, return zero if NAME is not
83 suitably defined. */
84
85struct symbol *
ef5ccd6c 86lookup_struct_typedef (char *name, const struct block *block, int noerr)
5796c8dc
SS
87{
88 struct symbol *sym;
89
90 sym = lookup_symbol (name, block, STRUCT_DOMAIN, 0);
91
92 if (sym == NULL)
93 {
94 if (noerr)
95 return 0;
96 else
97 error (_("No struct type named %s."), name);
98 }
99 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_STRUCT)
100 {
101 if (noerr)
102 return 0;
103 else
104 error (_("This context has class, union or enum %s, not a struct."),
105 name);
106 }
107 return sym;
108}
109
110CORE_ADDR
111lookup_objc_class (struct gdbarch *gdbarch, char *classname)
112{
113 struct type *char_type = builtin_type (gdbarch)->builtin_char;
114 struct value * function, *classval;
115
116 if (! target_has_execution)
117 {
118 /* Can't call into inferior to lookup class. */
119 return 0;
120 }
121
122 if (lookup_minimal_symbol("objc_lookUpClass", 0, 0))
123 function = find_function_in_inferior("objc_lookUpClass", NULL);
124 else if (lookup_minimal_symbol ("objc_lookup_class", 0, 0))
125 function = find_function_in_inferior("objc_lookup_class", NULL);
126 else
127 {
c50c785c
JM
128 complaint (&symfile_complaints,
129 _("no way to lookup Objective-C classes"));
5796c8dc
SS
130 return 0;
131 }
132
133 classval = value_string (classname, strlen (classname) + 1, char_type);
134 classval = value_coerce_array (classval);
135 return (CORE_ADDR) value_as_long (call_function_by_hand (function,
136 1, &classval));
137}
138
139CORE_ADDR
140lookup_child_selector (struct gdbarch *gdbarch, char *selname)
141{
142 struct type *char_type = builtin_type (gdbarch)->builtin_char;
143 struct value * function, *selstring;
144
145 if (! target_has_execution)
146 {
147 /* Can't call into inferior to lookup selector. */
148 return 0;
149 }
150
151 if (lookup_minimal_symbol("sel_getUid", 0, 0))
152 function = find_function_in_inferior("sel_getUid", NULL);
153 else if (lookup_minimal_symbol ("sel_get_any_uid", 0, 0))
154 function = find_function_in_inferior("sel_get_any_uid", NULL);
155 else
156 {
c50c785c
JM
157 complaint (&symfile_complaints,
158 _("no way to lookup Objective-C selectors"));
5796c8dc
SS
159 return 0;
160 }
161
162 selstring = value_coerce_array (value_string (selname,
c50c785c
JM
163 strlen (selname) + 1,
164 char_type));
5796c8dc
SS
165 return value_as_long (call_function_by_hand (function, 1, &selstring));
166}
167
168struct value *
169value_nsstring (struct gdbarch *gdbarch, char *ptr, int len)
170{
171 struct type *char_type = builtin_type (gdbarch)->builtin_char;
172 struct value *stringValue[3];
173 struct value *function, *nsstringValue;
174 struct symbol *sym;
175 struct type *type;
176
177 if (!target_has_execution)
178 return 0; /* Can't call into inferior to create NSString. */
179
180 stringValue[2] = value_string(ptr, len, char_type);
181 stringValue[2] = value_coerce_array(stringValue[2]);
182 /* _NSNewStringFromCString replaces "istr" after Lantern2A. */
183 if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
184 {
185 function = find_function_in_inferior("_NSNewStringFromCString", NULL);
186 nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
187 }
188 else if (lookup_minimal_symbol("istr", 0, 0))
189 {
190 function = find_function_in_inferior("istr", NULL);
191 nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
192 }
193 else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
194 {
195 function
196 = find_function_in_inferior("+[NSString stringWithCString:]", NULL);
197 type = builtin_type (gdbarch)->builtin_long;
198
199 stringValue[0] = value_from_longest
200 (type, lookup_objc_class (gdbarch, "NSString"));
201 stringValue[1] = value_from_longest
202 (type, lookup_child_selector (gdbarch, "stringWithCString:"));
203 nsstringValue = call_function_by_hand(function, 3, &stringValue[0]);
204 }
205 else
206 error (_("NSString: internal error -- no way to create new NSString"));
207
208 sym = lookup_struct_typedef("NSString", 0, 1);
209 if (sym == NULL)
210 sym = lookup_struct_typedef("NXString", 0, 1);
211 if (sym == NULL)
212 type = builtin_type (gdbarch)->builtin_data_ptr;
213 else
214 type = lookup_pointer_type(SYMBOL_TYPE (sym));
215
216 deprecated_set_value_type (nsstringValue, type);
217 return nsstringValue;
218}
219
220/* Objective-C name demangling. */
221
222char *
223objc_demangle (const char *mangled, int options)
224{
225 char *demangled, *cp;
226
227 if (mangled[0] == '_' &&
228 (mangled[1] == 'i' || mangled[1] == 'c') &&
229 mangled[2] == '_')
230 {
231 cp = demangled = xmalloc(strlen(mangled) + 2);
232
233 if (mangled[1] == 'i')
234 *cp++ = '-'; /* for instance method */
235 else
236 *cp++ = '+'; /* for class method */
237
238 *cp++ = '['; /* opening left brace */
c50c785c 239 strcpy(cp, mangled+3); /* Tack on the rest of the mangled name. */
5796c8dc
SS
240
241 while (*cp && *cp == '_')
c50c785c
JM
242 cp++; /* Skip any initial underbars in class
243 name. */
5796c8dc
SS
244
245 cp = strchr(cp, '_');
c50c785c 246 if (!cp) /* Find first non-initial underbar. */
5796c8dc
SS
247 {
248 xfree(demangled); /* not mangled name */
249 return NULL;
250 }
c50c785c 251 if (cp[1] == '_') /* Easy case: no category name. */
cf7f2e2d 252 {
c50c785c 253 *cp++ = ' '; /* Replace two '_' with one ' '. */
cf7f2e2d
JM
254 strcpy(cp, mangled + (cp - demangled) + 2);
255 }
256 else
257 {
c50c785c 258 *cp++ = '('; /* Less easy case: category name. */
cf7f2e2d
JM
259 cp = strchr(cp, '_');
260 if (!cp)
261 {
262 xfree(demangled); /* not mangled name */
263 return NULL;
264 }
265 *cp++ = ')';
c50c785c
JM
266 *cp++ = ' '; /* Overwriting 1st char of method name... */
267 strcpy(cp, mangled + (cp - demangled)); /* Get it back. */
cf7f2e2d 268 }
5796c8dc
SS
269
270 while (*cp && *cp == '_')
c50c785c
JM
271 cp++; /* Skip any initial underbars in
272 method name. */
5796c8dc
SS
273
274 for (; *cp; cp++)
275 if (*cp == '_')
c50c785c 276 *cp = ':'; /* Replace remaining '_' with ':'. */
5796c8dc
SS
277
278 *cp++ = ']'; /* closing right brace */
279 *cp++ = 0; /* string terminator */
280 return demangled;
281 }
282 else
283 return NULL; /* Not an objc mangled name. */
284}
285
5796c8dc
SS
286/* Determine if we are currently in the Objective-C dispatch function.
287 If so, get the address of the method function that the dispatcher
c50c785c 288 would call and use that as the function to step into instead. Also
5796c8dc
SS
289 skip over the trampoline for the function (if any). This is better
290 for the user since they are only interested in stepping into the
291 method function anyway. */
292static CORE_ADDR
293objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
294{
295 struct gdbarch *gdbarch = get_frame_arch (frame);
296 CORE_ADDR real_stop_pc;
297 CORE_ADDR method_stop_pc;
298
299 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
300
301 if (real_stop_pc != 0)
302 find_objc_msgcall (real_stop_pc, &method_stop_pc);
303 else
304 find_objc_msgcall (stop_pc, &method_stop_pc);
305
306 if (method_stop_pc)
307 {
308 real_stop_pc = gdbarch_skip_trampoline_code
309 (gdbarch, frame, method_stop_pc);
310 if (real_stop_pc == 0)
311 real_stop_pc = method_stop_pc;
312 }
313
314 return real_stop_pc;
315}
316
317
318/* Table mapping opcodes into strings for printing operators
319 and precedences of the operators. */
320
321static const struct op_print objc_op_print_tab[] =
322 {
323 {",", BINOP_COMMA, PREC_COMMA, 0},
324 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
325 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
326 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
327 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
328 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
329 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
330 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
331 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
332 {"<=", BINOP_LEQ, PREC_ORDER, 0},
333 {">=", BINOP_GEQ, PREC_ORDER, 0},
334 {">", BINOP_GTR, PREC_ORDER, 0},
335 {"<", BINOP_LESS, PREC_ORDER, 0},
336 {">>", BINOP_RSH, PREC_SHIFT, 0},
337 {"<<", BINOP_LSH, PREC_SHIFT, 0},
338 {"+", BINOP_ADD, PREC_ADD, 0},
339 {"-", BINOP_SUB, PREC_ADD, 0},
340 {"*", BINOP_MUL, PREC_MUL, 0},
341 {"/", BINOP_DIV, PREC_MUL, 0},
342 {"%", BINOP_REM, PREC_MUL, 0},
343 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
344 {"-", UNOP_NEG, PREC_PREFIX, 0},
345 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
346 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
347 {"*", UNOP_IND, PREC_PREFIX, 0},
348 {"&", UNOP_ADDR, PREC_PREFIX, 0},
349 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
350 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
351 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
352 {NULL, OP_NULL, PREC_NULL, 0}
353};
354
355const struct language_defn objc_language_defn = {
356 "objective-c", /* Language name */
357 language_objc,
358 range_check_off,
5796c8dc
SS
359 case_sensitive_on,
360 array_row_major,
361 macro_expansion_c,
362 &exp_descriptor_standard,
ef5ccd6c
JM
363 c_parse,
364 c_error,
5796c8dc 365 null_post_parser,
ef5ccd6c
JM
366 c_printchar, /* Print a character constant */
367 c_printstr, /* Function to print string constant */
368 c_emit_char,
5796c8dc
SS
369 c_print_type, /* Print a type using appropriate syntax */
370 c_print_typedef, /* Print a typedef using appropriate syntax */
371 c_val_print, /* Print a value using appropriate syntax */
372 c_value_print, /* Print a top-level value */
ef5ccd6c 373 default_read_var_value, /* la_read_var_value */
5796c8dc
SS
374 objc_skip_trampoline, /* Language specific skip_trampoline */
375 "self", /* name_of_this */
376 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
377 basic_lookup_transparent_type,/* lookup_transparent_type */
378 objc_demangle, /* Language specific symbol demangler */
c50c785c
JM
379 NULL, /* Language specific
380 class_name_from_physname */
5796c8dc
SS
381 objc_op_print_tab, /* Expression operators for printing */
382 1, /* C-style arrays */
383 0, /* String lower bound */
384 default_word_break_characters,
385 default_make_symbol_completion_list,
386 c_language_arch_info,
387 default_print_array_index,
388 default_pass_by_reference,
389 default_get_string,
ef5ccd6c 390 NULL, /* la_get_symbol_name_cmp */
a45ae5f8 391 iterate_over_symbols,
5796c8dc
SS
392 LANG_MAGIC
393};
394
395/*
396 * ObjC:
c50c785c 397 * Following functions help construct Objective-C message calls.
5796c8dc
SS
398 */
399
400struct selname /* For parsing Objective-C. */
401 {
402 struct selname *next;
403 char *msglist_sel;
404 int msglist_len;
405 };
406
407static int msglist_len;
408static struct selname *selname_chain;
409static char *msglist_sel;
410
411void
412start_msglist(void)
413{
414 struct selname *new =
415 (struct selname *) xmalloc (sizeof (struct selname));
416
417 new->next = selname_chain;
418 new->msglist_len = msglist_len;
419 new->msglist_sel = msglist_sel;
420 msglist_len = 0;
421 msglist_sel = (char *)xmalloc(1);
422 *msglist_sel = 0;
423 selname_chain = new;
424}
425
426void
427add_msglist(struct stoken *str, int addcolon)
428{
429 char *s, *p;
430 int len, plen;
431
cf7f2e2d
JM
432 if (str == 0) /* Unnamed arg, or... */
433 {
434 if (addcolon == 0) /* variable number of args. */
435 {
436 msglist_len++;
437 return;
438 }
439 p = "";
440 plen = 0;
441 }
442 else
443 {
444 p = str->ptr;
445 plen = str->length;
5796c8dc 446 }
5796c8dc
SS
447 len = plen + strlen(msglist_sel) + 2;
448 s = (char *)xmalloc(len);
449 strcpy(s, msglist_sel);
450 strncat(s, p, plen);
451 xfree(msglist_sel);
452 msglist_sel = s;
cf7f2e2d
JM
453 if (addcolon)
454 {
455 s[len-2] = ':';
456 s[len-1] = 0;
457 msglist_len++;
458 }
459 else
5796c8dc
SS
460 s[len-2] = '\0';
461}
462
463int
464end_msglist(void)
465{
466 int val = msglist_len;
467 struct selname *sel = selname_chain;
468 char *p = msglist_sel;
469 CORE_ADDR selid;
470
471 selname_chain = sel->next;
472 msglist_len = sel->msglist_len;
473 msglist_sel = sel->msglist_sel;
474 selid = lookup_child_selector (parse_gdbarch, p);
475 if (!selid)
476 error (_("Can't find selector \"%s\""), p);
477 write_exp_elt_longcst (selid);
478 xfree(p);
479 write_exp_elt_longcst (val); /* Number of args */
480 xfree(sel);
481
482 return val;
483}
484
485/*
ef5ccd6c 486 * Function: specialcmp (const char *a, const char *b)
5796c8dc
SS
487 *
488 * Special strcmp: treats ']' and ' ' as end-of-string.
489 * Used for qsorting lists of objc methods (either by class or selector).
490 */
491
492static int
ef5ccd6c 493specialcmp (const char *a, const char *b)
5796c8dc
SS
494{
495 while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']')
496 {
497 if (*a != *b)
498 return *a - *b;
499 a++, b++;
500 }
501 if (*a && *a != ' ' && *a != ']')
c50c785c 502 return 1; /* a is longer therefore greater. */
5796c8dc 503 if (*b && *b != ' ' && *b != ']')
c50c785c
JM
504 return -1; /* a is shorter therefore lesser. */
505 return 0; /* a and b are identical. */
5796c8dc
SS
506}
507
508/*
509 * Function: compare_selectors (const void *, const void *)
510 *
511 * Comparison function for use with qsort. Arguments are symbols or
512 * msymbols Compares selector part of objc method name alphabetically.
513 */
514
515static int
516compare_selectors (const void *a, const void *b)
517{
ef5ccd6c 518 const char *aname, *bname;
5796c8dc
SS
519
520 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
521 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
522 if (aname == NULL || bname == NULL)
523 error (_("internal: compare_selectors(1)"));
524
525 aname = strchr(aname, ' ');
526 bname = strchr(bname, ' ');
527 if (aname == NULL || bname == NULL)
528 error (_("internal: compare_selectors(2)"));
529
530 return specialcmp (aname+1, bname+1);
531}
532
533/*
534 * Function: selectors_info (regexp, from_tty)
535 *
536 * Implements the "Info selectors" command. Takes an optional regexp
537 * arg. Lists all objective c selectors that match the regexp. Works
538 * by grepping thru all symbols for objective c methods. Output list
539 * is sorted and uniqued.
540 */
541
542static void
543selectors_info (char *regexp, int from_tty)
544{
545 struct objfile *objfile;
546 struct minimal_symbol *msymbol;
ef5ccd6c 547 const char *name;
5796c8dc
SS
548 char *val;
549 int matches = 0;
550 int maxlen = 0;
551 int ix;
552 char myregexp[2048];
553 char asel[256];
554 struct symbol **sym_arr;
555 int plusminus = 0;
556
557 if (regexp == NULL)
558 strcpy(myregexp, ".*]"); /* Null input, match all objc methods. */
559 else
560 {
561 if (*regexp == '+' || *regexp == '-')
562 { /* User wants only class methods or only instance methods. */
563 plusminus = *regexp++;
564 while (*regexp == ' ' || *regexp == '\t')
565 regexp++;
566 }
567 if (*regexp == '\0')
568 strcpy(myregexp, ".*]");
569 else
570 {
c50c785c
JM
571 /* Allow a few extra bytes because of the strcat below. */
572 if (sizeof (myregexp) < strlen (regexp) + 4)
573 error (_("Regexp is too long: %s"), regexp);
5796c8dc
SS
574 strcpy(myregexp, regexp);
575 if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
576 myregexp[strlen(myregexp) - 1] = ']'; /* end of method name */
577 else
578 strcat(myregexp, ".*]");
579 }
580 }
581
582 if (regexp != NULL)
583 {
584 val = re_comp (myregexp);
585 if (val != 0)
586 error (_("Invalid regexp (%s): %s"), val, regexp);
587 }
588
589 /* First time thru is JUST to get max length and count. */
590 ALL_MSYMBOLS (objfile, msymbol)
591 {
592 QUIT;
593 name = SYMBOL_NATURAL_NAME (msymbol);
c50c785c
JM
594 if (name
595 && (name[0] == '-' || name[0] == '+')
596 && name[1] == '[') /* Got a method name. */
5796c8dc
SS
597 {
598 /* Filter for class/instance methods. */
599 if (plusminus && name[0] != plusminus)
600 continue;
601 /* Find selector part. */
c50c785c
JM
602 name = (char *) strchr (name+2, ' ');
603 if (name == NULL)
604 {
605 complaint (&symfile_complaints,
606 _("Bad method name '%s'"),
607 SYMBOL_NATURAL_NAME (msymbol));
608 continue;
609 }
5796c8dc
SS
610 if (regexp == NULL || re_exec(++name) != 0)
611 {
ef5ccd6c
JM
612 const char *mystart = name;
613 const char *myend = strchr (mystart, ']');
5796c8dc
SS
614
615 if (myend && (myend - mystart > maxlen))
616 maxlen = myend - mystart; /* Get longest selector. */
617 matches++;
618 }
619 }
620 }
621 if (matches)
622 {
623 printf_filtered (_("Selectors matching \"%s\":\n\n"),
624 regexp ? regexp : "*");
625
626 sym_arr = alloca (matches * sizeof (struct symbol *));
627 matches = 0;
628 ALL_MSYMBOLS (objfile, msymbol)
629 {
630 QUIT;
631 name = SYMBOL_NATURAL_NAME (msymbol);
632 if (name &&
633 (name[0] == '-' || name[0] == '+') &&
634 name[1] == '[') /* Got a method name. */
635 {
636 /* Filter for class/instance methods. */
637 if (plusminus && name[0] != plusminus)
638 continue;
639 /* Find selector part. */
640 name = (char *) strchr(name+2, ' ');
641 if (regexp == NULL || re_exec(++name) != 0)
642 sym_arr[matches++] = (struct symbol *) msymbol;
643 }
644 }
645
646 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
647 compare_selectors);
648 /* Prevent compare on first iteration. */
649 asel[0] = 0;
650 for (ix = 0; ix < matches; ix++) /* Now do the output. */
651 {
652 char *p = asel;
653
654 QUIT;
655 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
656 name = strchr (name, ' ') + 1;
657 if (p[0] && specialcmp(name, p) == 0)
658 continue; /* Seen this one already (not unique). */
659
660 /* Copy selector part. */
661 while (*name && *name != ']')
662 *p++ = *name++;
663 *p++ = '\0';
664 /* Print in columns. */
665 puts_filtered_tabular(asel, maxlen + 1, 0);
666 }
667 begin_line();
668 }
669 else
c50c785c
JM
670 printf_filtered (_("No selectors matching \"%s\"\n"),
671 regexp ? regexp : "*");
5796c8dc
SS
672}
673
674/*
675 * Function: compare_classes (const void *, const void *)
676 *
677 * Comparison function for use with qsort. Arguments are symbols or
678 * msymbols Compares class part of objc method name alphabetically.
679 */
680
681static int
682compare_classes (const void *a, const void *b)
683{
ef5ccd6c 684 const char *aname, *bname;
5796c8dc
SS
685
686 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
687 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
688 if (aname == NULL || bname == NULL)
689 error (_("internal: compare_classes(1)"));
690
691 return specialcmp (aname+1, bname+1);
692}
693
694/*
695 * Function: classes_info(regexp, from_tty)
696 *
697 * Implements the "info classes" command for objective c classes.
698 * Lists all objective c classes that match the optional regexp.
699 * Works by grepping thru the list of objective c methods. List will
700 * be sorted and uniqued (since one class may have many methods).
701 * BUGS: will not list a class that has no methods.
702 */
703
704static void
705classes_info (char *regexp, int from_tty)
706{
707 struct objfile *objfile;
708 struct minimal_symbol *msymbol;
ef5ccd6c 709 const char *name;
5796c8dc
SS
710 char *val;
711 int matches = 0;
712 int maxlen = 0;
713 int ix;
714 char myregexp[2048];
715 char aclass[256];
716 struct symbol **sym_arr;
717
718 if (regexp == NULL)
719 strcpy(myregexp, ".* "); /* Null input: match all objc classes. */
720 else
721 {
c50c785c
JM
722 /* Allow a few extra bytes because of the strcat below. */
723 if (sizeof (myregexp) < strlen (regexp) + 4)
724 error (_("Regexp is too long: %s"), regexp);
5796c8dc
SS
725 strcpy(myregexp, regexp);
726 if (myregexp[strlen(myregexp) - 1] == '$')
727 /* In the method name, the end of the class name is marked by ' '. */
728 myregexp[strlen(myregexp) - 1] = ' ';
729 else
730 strcat(myregexp, ".* ");
731 }
732
733 if (regexp != NULL)
734 {
735 val = re_comp (myregexp);
736 if (val != 0)
737 error (_("Invalid regexp (%s): %s"), val, regexp);
738 }
739
740 /* First time thru is JUST to get max length and count. */
741 ALL_MSYMBOLS (objfile, msymbol)
742 {
743 QUIT;
744 name = SYMBOL_NATURAL_NAME (msymbol);
745 if (name &&
746 (name[0] == '-' || name[0] == '+') &&
747 name[1] == '[') /* Got a method name. */
748 if (regexp == NULL || re_exec(name+2) != 0)
749 {
750 /* Compute length of classname part. */
ef5ccd6c
JM
751 const char *mystart = name + 2;
752 const char *myend = strchr (mystart, ' ');
5796c8dc
SS
753
754 if (myend && (myend - mystart > maxlen))
755 maxlen = myend - mystart;
756 matches++;
757 }
758 }
759 if (matches)
760 {
761 printf_filtered (_("Classes matching \"%s\":\n\n"),
762 regexp ? regexp : "*");
763 sym_arr = alloca (matches * sizeof (struct symbol *));
764 matches = 0;
765 ALL_MSYMBOLS (objfile, msymbol)
766 {
767 QUIT;
768 name = SYMBOL_NATURAL_NAME (msymbol);
769 if (name &&
770 (name[0] == '-' || name[0] == '+') &&
771 name[1] == '[') /* Got a method name. */
772 if (regexp == NULL || re_exec(name+2) != 0)
773 sym_arr[matches++] = (struct symbol *) msymbol;
774 }
775
776 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
777 compare_classes);
778 /* Prevent compare on first iteration. */
779 aclass[0] = 0;
780 for (ix = 0; ix < matches; ix++) /* Now do the output. */
781 {
782 char *p = aclass;
783
784 QUIT;
785 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
786 name += 2;
787 if (p[0] && specialcmp(name, p) == 0)
788 continue; /* Seen this one already (not unique). */
789
790 /* Copy class part of method name. */
791 while (*name && *name != ' ')
792 *p++ = *name++;
793 *p++ = '\0';
794 /* Print in columns. */
795 puts_filtered_tabular(aclass, maxlen + 1, 0);
796 }
797 begin_line();
798 }
799 else
800 printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*");
801}
802
a45ae5f8 803static char *
5796c8dc
SS
804parse_selector (char *method, char **selector)
805{
806 char *s1 = NULL;
807 char *s2 = NULL;
808 int found_quote = 0;
809
810 char *nselector = NULL;
811
812 gdb_assert (selector != NULL);
813
814 s1 = method;
815
ef5ccd6c 816 s1 = skip_spaces (s1);
5796c8dc
SS
817 if (*s1 == '\'')
818 {
819 found_quote = 1;
820 s1++;
821 }
ef5ccd6c 822 s1 = skip_spaces (s1);
5796c8dc
SS
823
824 nselector = s1;
825 s2 = s1;
826
cf7f2e2d
JM
827 for (;;)
828 {
829 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
830 *s1++ = *s2;
831 else if (isspace (*s2))
832 ;
833 else if ((*s2 == '\0') || (*s2 == '\''))
834 break;
835 else
836 return NULL;
837 s2++;
838 }
5796c8dc
SS
839 *s1++ = '\0';
840
ef5ccd6c 841 s2 = skip_spaces (s2);
5796c8dc
SS
842 if (found_quote)
843 {
844 if (*s2 == '\'')
845 s2++;
ef5ccd6c 846 s2 = skip_spaces (s2);
5796c8dc
SS
847 }
848
849 if (selector != NULL)
850 *selector = nselector;
851
852 return s2;
853}
854
a45ae5f8 855static char *
5796c8dc
SS
856parse_method (char *method, char *type, char **class,
857 char **category, char **selector)
858{
859 char *s1 = NULL;
860 char *s2 = NULL;
861 int found_quote = 0;
862
863 char ntype = '\0';
864 char *nclass = NULL;
865 char *ncategory = NULL;
866 char *nselector = NULL;
867
868 gdb_assert (type != NULL);
869 gdb_assert (class != NULL);
870 gdb_assert (category != NULL);
871 gdb_assert (selector != NULL);
872
873 s1 = method;
874
ef5ccd6c 875 s1 = skip_spaces (s1);
5796c8dc
SS
876 if (*s1 == '\'')
877 {
878 found_quote = 1;
879 s1++;
880 }
ef5ccd6c 881 s1 = skip_spaces (s1);
5796c8dc
SS
882
883 if ((s1[0] == '+') || (s1[0] == '-'))
884 ntype = *s1++;
885
ef5ccd6c 886 s1 = skip_spaces (s1);
5796c8dc
SS
887
888 if (*s1 != '[')
889 return NULL;
890 s1++;
891
892 nclass = s1;
893 while (isalnum (*s1) || (*s1 == '_'))
894 s1++;
895
896 s2 = s1;
ef5ccd6c 897 s2 = skip_spaces (s2);
5796c8dc
SS
898
899 if (*s2 == '(')
900 {
901 s2++;
ef5ccd6c 902 s2 = skip_spaces (s2);
5796c8dc
SS
903 ncategory = s2;
904 while (isalnum (*s2) || (*s2 == '_'))
905 s2++;
906 *s2++ = '\0';
907 }
908
909 /* Truncate the class name now that we're not using the open paren. */
910 *s1++ = '\0';
911
912 nselector = s2;
913 s1 = s2;
914
cf7f2e2d
JM
915 for (;;)
916 {
917 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
918 *s1++ = *s2;
919 else if (isspace (*s2))
920 ;
921 else if (*s2 == ']')
922 break;
923 else
924 return NULL;
925 s2++;
926 }
5796c8dc
SS
927 *s1++ = '\0';
928 s2++;
929
ef5ccd6c 930 s2 = skip_spaces (s2);
5796c8dc
SS
931 if (found_quote)
932 {
933 if (*s2 != '\'')
934 return NULL;
935 s2++;
ef5ccd6c 936 s2 = skip_spaces (s2);
5796c8dc
SS
937 }
938
939 if (type != NULL)
940 *type = ntype;
941 if (class != NULL)
942 *class = nclass;
943 if (category != NULL)
944 *category = ncategory;
945 if (selector != NULL)
946 *selector = nselector;
947
948 return s2;
949}
950
951static void
a45ae5f8
JM
952find_methods (char type, const char *class, const char *category,
953 const char *selector,
954 VEC (const_char_ptr) **symbol_names)
5796c8dc
SS
955{
956 struct objfile *objfile = NULL;
5796c8dc 957
ef5ccd6c 958 const char *symname = NULL;
5796c8dc
SS
959
960 char ntype = '\0';
961 char *nclass = NULL;
962 char *ncategory = NULL;
963 char *nselector = NULL;
964
5796c8dc
SS
965 static char *tmp = NULL;
966 static unsigned int tmplen = 0;
967
a45ae5f8 968 gdb_assert (symbol_names != NULL);
5796c8dc
SS
969
970 ALL_OBJFILES (objfile)
971 {
972 unsigned int *objc_csym;
a45ae5f8 973 struct minimal_symbol *msymbol = NULL;
5796c8dc
SS
974
975 /* The objfile_csym variable counts the number of ObjC methods
976 that this objfile defines. We save that count as a private
977 objfile data. If we have already determined that this objfile
978 provides no ObjC methods, we can skip it entirely. */
979
980 unsigned int objfile_csym = 0;
981
982 objc_csym = objfile_data (objfile, objc_objfile_data);
983 if (objc_csym != NULL && *objc_csym == 0)
984 /* There are no ObjC symbols in this objfile. Skip it entirely. */
985 continue;
986
987 ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
988 {
cf7f2e2d 989 QUIT;
5796c8dc 990
cf7f2e2d
JM
991 /* Check the symbol name first as this can be done entirely without
992 sending any query to the target. */
5796c8dc
SS
993 symname = SYMBOL_NATURAL_NAME (msymbol);
994 if (symname == NULL)
995 continue;
996
997 if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
998 /* Not a method name. */
999 continue;
cf7f2e2d 1000
c50c785c
JM
1001 objfile_csym++;
1002
cf7f2e2d 1003 /* Now that thinks are a bit sane, clean up the symname. */
5796c8dc
SS
1004 while ((strlen (symname) + 1) >= tmplen)
1005 {
1006 tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1007 tmp = xrealloc (tmp, tmplen);
1008 }
1009 strcpy (tmp, symname);
1010
c50c785c
JM
1011 if (parse_method (tmp, &ntype, &nclass,
1012 &ncategory, &nselector) == NULL)
5796c8dc 1013 continue;
5796c8dc
SS
1014
1015 if ((type != '\0') && (ntype != type))
1016 continue;
1017
1018 if ((class != NULL)
1019 && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1020 continue;
1021
1022 if ((category != NULL) &&
1023 ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1024 continue;
1025
1026 if ((selector != NULL) &&
1027 ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1028 continue;
1029
a45ae5f8 1030 VEC_safe_push (const_char_ptr, *symbol_names, symname);
5796c8dc 1031 }
a45ae5f8 1032
5796c8dc
SS
1033 if (objc_csym == NULL)
1034 {
1035 objc_csym = obstack_alloc (&objfile->objfile_obstack,
1036 sizeof (*objc_csym));
1037 *objc_csym = objfile_csym;
1038 set_objfile_data (objfile, objc_objfile_data, objc_csym);
1039 }
1040 else
1041 /* Count of ObjC methods in this objfile should be constant. */
1042 gdb_assert (*objc_csym == objfile_csym);
1043 }
a45ae5f8 1044}
5796c8dc 1045
a45ae5f8
JM
1046/* Uniquify a VEC of strings. */
1047
1048static void
1049uniquify_strings (VEC (const_char_ptr) **strings)
1050{
1051 int ix;
1052 const char *elem, *last = NULL;
1053 int out;
1054
1055 qsort (VEC_address (const_char_ptr, *strings),
1056 VEC_length (const_char_ptr, *strings),
1057 sizeof (const_char_ptr),
1058 compare_strings);
1059 out = 0;
1060 for (ix = 0; VEC_iterate (const_char_ptr, *strings, ix, elem); ++ix)
1061 {
1062 if (last == NULL || strcmp (last, elem) != 0)
1063 {
1064 /* Keep ELEM. */
1065 VEC_replace (const_char_ptr, *strings, out, elem);
1066 ++out;
1067 }
1068 last = elem;
1069 }
1070 VEC_truncate (const_char_ptr, *strings, out);
5796c8dc
SS
1071}
1072
a45ae5f8
JM
1073/*
1074 * Function: find_imps (char *selector, struct symbol **sym_arr)
1075 *
1076 * Input: a string representing a selector
1077 * a pointer to an array of symbol pointers
1078 * possibly a pointer to a symbol found by the caller.
1079 *
1080 * Output: number of methods that implement that selector. Side
1081 * effects: The array of symbol pointers is filled with matching syms.
1082 *
1083 * By analogy with function "find_methods" (symtab.c), builds a list
1084 * of symbols matching the ambiguous input, so that "decode_line_2"
1085 * (symtab.c) can list them and ask the user to choose one or more.
1086 * In this case the matches are objective c methods
1087 * ("implementations") matching an objective c selector.
1088 *
1089 * Note that it is possible for a normal (c-style) function to have
1090 * the same name as an objective c selector. To prevent the selector
1091 * from eclipsing the function, we allow the caller (decode_line_1) to
1092 * search for such a function first, and if it finds one, pass it in
1093 * to us. We will then integrate it into the list. We also search
1094 * for one here, among the minsyms.
1095 *
1096 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
1097 * into two parts: debuggable (struct symbol) syms, and
1098 * non_debuggable (struct minimal_symbol) syms. The debuggable
1099 * ones will come first, before NUM_DEBUGGABLE (which will thus
1100 * be the index of the first non-debuggable one).
1101 */
1102
1103char *
1104find_imps (char *method, VEC (const_char_ptr) **symbol_names)
5796c8dc
SS
1105{
1106 char type = '\0';
1107 char *class = NULL;
1108 char *category = NULL;
1109 char *selector = NULL;
1110
5796c8dc
SS
1111 char *buf = NULL;
1112 char *tmp = NULL;
1113
a45ae5f8 1114 int selector_case = 0;
5796c8dc 1115
a45ae5f8 1116 gdb_assert (symbol_names != NULL);
5796c8dc
SS
1117
1118 buf = (char *) alloca (strlen (method) + 1);
1119 strcpy (buf, method);
1120 tmp = parse_method (buf, &type, &class, &category, &selector);
1121
cf7f2e2d
JM
1122 if (tmp == NULL)
1123 {
cf7f2e2d
JM
1124 strcpy (buf, method);
1125 tmp = parse_selector (buf, &selector);
5796c8dc 1126
cf7f2e2d
JM
1127 if (tmp == NULL)
1128 return NULL;
1129
a45ae5f8 1130 selector_case = 1;
cf7f2e2d 1131 }
5796c8dc 1132
a45ae5f8 1133 find_methods (type, class, category, selector, symbol_names);
5796c8dc 1134
a45ae5f8
JM
1135 /* If we hit the "selector" case, and we found some methods, then
1136 add the selector itself as a symbol, if it exists. */
1137 if (selector_case && !VEC_empty (const_char_ptr, *symbol_names))
5796c8dc 1138 {
a45ae5f8
JM
1139 struct symbol *sym = lookup_symbol (selector, NULL, VAR_DOMAIN, 0);
1140
1141 if (sym != NULL)
1142 VEC_safe_push (const_char_ptr, *symbol_names,
1143 SYMBOL_NATURAL_NAME (sym));
1144 else
5796c8dc 1145 {
a45ae5f8
JM
1146 struct minimal_symbol *msym = lookup_minimal_symbol (selector, 0, 0);
1147
1148 if (msym != NULL)
1149 VEC_safe_push (const_char_ptr, *symbol_names,
1150 SYMBOL_NATURAL_NAME (msym));
5796c8dc
SS
1151 }
1152 }
1153
a45ae5f8 1154 uniquify_strings (symbol_names);
5796c8dc
SS
1155
1156 return method + (tmp - buf);
1157}
1158
1159static void
1160print_object_command (char *args, int from_tty)
1161{
1162 struct value *object, *function, *description;
1163 CORE_ADDR string_addr, object_addr;
1164 int i = 0;
1165 gdb_byte c = 0;
1166
1167 if (!args || !*args)
1168 error (
1169"The 'print-object' command requires an argument (an Objective-C object)");
1170
1171 {
1172 struct expression *expr = parse_expression (args);
1173 struct cleanup *old_chain =
1174 make_cleanup (free_current_contents, &expr);
1175 int pc = 0;
1176
1177 object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1178 expr, &pc, EVAL_NORMAL);
1179 do_cleanups (old_chain);
1180 }
1181
1182 /* Validate the address for sanity. */
1183 object_addr = value_as_long (object);
1184 read_memory (object_addr, &c, 1);
1185
1186 function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1187 if (function == NULL)
1188 error (_("Unable to locate _NSPrintForDebugger in child process"));
1189
1190 description = call_function_by_hand (function, 1, &object);
1191
1192 string_addr = value_as_long (description);
1193 if (string_addr == 0)
1194 error (_("object returns null description"));
1195
1196 read_memory (string_addr + i++, &c, 1);
1197 if (c != 0)
1198 do
1199 { /* Read and print characters up to EOS. */
1200 QUIT;
1201 printf_filtered ("%c", c);
1202 read_memory (string_addr + i++, &c, 1);
1203 } while (c != 0);
1204 else
1205 printf_filtered(_("<object returns empty description>"));
1206 printf_filtered ("\n");
1207}
1208
1209/* The data structure 'methcalls' is used to detect method calls (thru
1210 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
c50c785c 1211 * and ultimately find the method being called.
5796c8dc
SS
1212 */
1213
1214struct objc_methcall {
1215 char *name;
1216 /* Return instance method to be called. */
1217 int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1218 /* Start of pc range corresponding to method invocation. */
1219 CORE_ADDR begin;
1220 /* End of pc range corresponding to method invocation. */
1221 CORE_ADDR end;
1222};
1223
1224static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1225static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1226static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1227static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1228
1229static struct objc_methcall methcalls[] = {
1230 { "_objc_msgSend", resolve_msgsend, 0, 0},
1231 { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1232 { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1233 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1234 { "_objc_getClass", NULL, 0, 0},
1235 { "_objc_getMetaClass", NULL, 0, 0}
1236};
1237
1238#define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1239
1240/* The following function, "find_objc_msgsend", fills in the data
1241 * structure "objc_msgs" by finding the addresses of each of the
1242 * (currently four) functions that it holds (of which objc_msgSend is
1243 * the first). This must be called each time symbols are loaded, in
c50c785c 1244 * case the functions have moved for some reason.
5796c8dc
SS
1245 */
1246
1247static void
1248find_objc_msgsend (void)
1249{
1250 unsigned int i;
5796c8dc 1251
cf7f2e2d
JM
1252 for (i = 0; i < nmethcalls; i++)
1253 {
1254 struct minimal_symbol *func;
5796c8dc 1255
cf7f2e2d
JM
1256 /* Try both with and without underscore. */
1257 func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1258 if ((func == NULL) && (methcalls[i].name[0] == '_'))
1259 {
1260 func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1261 }
1262 if (func == NULL)
1263 {
1264 methcalls[i].begin = 0;
1265 methcalls[i].end = 0;
1266 continue;
1267 }
1268
1269 methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1270 do {
1271 methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1272 } while (methcalls[i].begin == methcalls[i].end);
5796c8dc 1273 }
5796c8dc
SS
1274}
1275
1276/* find_objc_msgcall (replaces pc_off_limits)
1277 *
1278 * ALL that this function now does is to determine whether the input
1279 * address ("pc") is the address of one of the Objective-C message
1280 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1281 * if so, it returns the address of the method that will be called.
1282 *
1283 * The old function "pc_off_limits" used to do a lot of other things
1284 * in addition, such as detecting shared library jump stubs and
1285 * returning the address of the shlib function that would be called.
1286 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1287 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
c50c785c 1288 * dependent modules.
5796c8dc
SS
1289 */
1290
1291struct objc_submethod_helper_data {
1292 int (*f) (CORE_ADDR, CORE_ADDR *);
1293 CORE_ADDR pc;
1294 CORE_ADDR *new_pc;
1295};
1296
1297static int
1298find_objc_msgcall_submethod_helper (void * arg)
1299{
1300 struct objc_submethod_helper_data *s =
1301 (struct objc_submethod_helper_data *) arg;
1302
1303 if (s->f (s->pc, s->new_pc) == 0)
1304 return 1;
1305 else
1306 return 0;
1307}
1308
1309static int
1310find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1311 CORE_ADDR pc,
1312 CORE_ADDR *new_pc)
1313{
1314 struct objc_submethod_helper_data s;
1315
1316 s.f = f;
1317 s.pc = pc;
1318 s.new_pc = new_pc;
1319
1320 if (catch_errors (find_objc_msgcall_submethod_helper,
1321 (void *) &s,
c50c785c
JM
1322 "Unable to determine target of "
1323 "Objective-C method call (ignoring):\n",
5796c8dc
SS
1324 RETURN_MASK_ALL) == 0)
1325 return 1;
1326 else
1327 return 0;
1328}
1329
1330int
1331find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1332{
1333 unsigned int i;
1334
1335 find_objc_msgsend ();
1336 if (new_pc != NULL)
1337 {
1338 *new_pc = 0;
1339 }
1340
1341 for (i = 0; i < nmethcalls; i++)
1342 if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1343 {
1344 if (methcalls[i].stop_at != NULL)
1345 return find_objc_msgcall_submethod (methcalls[i].stop_at,
1346 pc, new_pc);
1347 else
1348 return 0;
1349 }
1350
1351 return 0;
1352}
1353
c50c785c
JM
1354/* -Wmissing-prototypes */
1355extern initialize_file_ftype _initialize_objc_language;
5796c8dc
SS
1356
1357void
1358_initialize_objc_language (void)
1359{
1360 add_language (&objc_language_defn);
1361 add_info ("selectors", selectors_info, /* INFO SELECTORS command. */
1362 _("All Objective-C selectors, or those matching REGEXP."));
1363 add_info ("classes", classes_info, /* INFO CLASSES command. */
1364 _("All Objective-C classes, or those matching REGEXP."));
1365 add_com ("print-object", class_vars, print_object_command,
1366 _("Ask an Objective-C object to print itself."));
1367 add_com_alias ("po", "print-object", class_vars, 1);
1368}
1369
1370static void
1371read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1372 struct objc_method *method)
1373{
1374 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
cf7f2e2d 1375
5796c8dc
SS
1376 method->name = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1377 method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1378 method->imp = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1379}
1380
1381static unsigned long
1382read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1383{
1384 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
cf7f2e2d 1385
5796c8dc
SS
1386 return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1387}
1388
1389static void
1390read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1391 unsigned long num, struct objc_method *method)
1392{
1393 gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1394 read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1395}
1396
1397static void
1398read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1399 struct objc_object *object)
1400{
1401 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
cf7f2e2d 1402
5796c8dc
SS
1403 object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1404}
1405
1406static void
1407read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1408 struct objc_super *super)
1409{
1410 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
cf7f2e2d 1411
5796c8dc
SS
1412 super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1413 super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1414};
1415
1416static void
1417read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1418 struct objc_class *class)
1419{
1420 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
cf7f2e2d 1421
5796c8dc
SS
1422 class->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1423 class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1424 class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1425 class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1426 class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
c50c785c
JM
1427 class->instance_size = read_memory_unsigned_integer (addr + 18, 4,
1428 byte_order);
5796c8dc
SS
1429 class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1430 class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1431 class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1432 class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1433}
1434
1435static CORE_ADDR
1436find_implementation_from_class (struct gdbarch *gdbarch,
1437 CORE_ADDR class, CORE_ADDR sel)
1438{
1439 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1440 CORE_ADDR subclass = class;
1441
1442 while (subclass != 0)
1443 {
1444
1445 struct objc_class class_str;
1446 unsigned mlistnum = 0;
1447
1448 read_objc_class (gdbarch, subclass, &class_str);
1449
1450 for (;;)
1451 {
1452 CORE_ADDR mlist;
1453 unsigned long nmethods;
1454 unsigned long i;
1455
1456 mlist = read_memory_unsigned_integer (class_str.methods +
1457 (4 * mlistnum),
1458 4, byte_order);
1459 if (mlist == 0)
1460 break;
1461
1462 nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1463
1464 for (i = 0; i < nmethods; i++)
1465 {
1466 struct objc_method meth_str;
5796c8dc 1467
cf7f2e2d 1468 read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
5796c8dc
SS
1469#if 0
1470 fprintf (stderr,
1471 "checking method 0x%lx against selector 0x%lx\n",
1472 meth_str.name, sel);
1473#endif
1474
1475 if (meth_str.name == sel)
1476 /* FIXME: hppa arch was doing a pointer dereference
c50c785c 1477 here. There needs to be a better way to do that. */
5796c8dc
SS
1478 return meth_str.imp;
1479 }
1480 mlistnum++;
1481 }
1482 subclass = class_str.super_class;
1483 }
1484
1485 return 0;
1486}
1487
1488static CORE_ADDR
1489find_implementation (struct gdbarch *gdbarch,
1490 CORE_ADDR object, CORE_ADDR sel)
1491{
1492 struct objc_object ostr;
1493
1494 if (object == 0)
1495 return 0;
1496 read_objc_object (gdbarch, object, &ostr);
1497 if (ostr.isa == 0)
1498 return 0;
1499
1500 return find_implementation_from_class (gdbarch, ostr.isa, sel);
1501}
1502
1503static int
1504resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1505{
1506 struct frame_info *frame = get_current_frame ();
1507 struct gdbarch *gdbarch = get_frame_arch (frame);
1508 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1509
1510 CORE_ADDR object;
1511 CORE_ADDR sel;
1512 CORE_ADDR res;
1513
1514 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1515 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1516
1517 res = find_implementation (gdbarch, object, sel);
1518 if (new_pc != 0)
1519 *new_pc = res;
1520 if (res == 0)
1521 return 1;
1522 return 0;
1523}
1524
1525static int
1526resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1527{
1528 struct frame_info *frame = get_current_frame ();
1529 struct gdbarch *gdbarch = get_frame_arch (frame);
1530 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1531
1532 CORE_ADDR object;
1533 CORE_ADDR sel;
1534 CORE_ADDR res;
1535
1536 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1537 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1538
1539 res = find_implementation (gdbarch, object, sel);
1540 if (new_pc != 0)
1541 *new_pc = res;
1542 if (res == 0)
1543 return 1;
1544 return 0;
1545}
1546
1547static int
1548resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1549{
1550 struct frame_info *frame = get_current_frame ();
1551 struct gdbarch *gdbarch = get_frame_arch (frame);
1552 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1553
1554 struct objc_super sstr;
1555
1556 CORE_ADDR super;
1557 CORE_ADDR sel;
1558 CORE_ADDR res;
1559
1560 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1561 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1562
1563 read_objc_super (gdbarch, super, &sstr);
1564 if (sstr.class == 0)
1565 return 0;
1566
1567 res = find_implementation_from_class (gdbarch, sstr.class, sel);
1568 if (new_pc != 0)
1569 *new_pc = res;
1570 if (res == 0)
1571 return 1;
1572 return 0;
1573}
1574
1575static int
1576resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1577{
1578 struct frame_info *frame = get_current_frame ();
1579 struct gdbarch *gdbarch = get_frame_arch (frame);
1580 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1581
1582 struct objc_super sstr;
1583
1584 CORE_ADDR super;
1585 CORE_ADDR sel;
1586 CORE_ADDR res;
1587
1588 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1589 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1590
1591 read_objc_super (gdbarch, super, &sstr);
1592 if (sstr.class == 0)
1593 return 0;
1594
1595 res = find_implementation_from_class (gdbarch, sstr.class, sel);
1596 if (new_pc != 0)
1597 *new_pc = res;
1598 if (res == 0)
1599 return 1;
1600 return 0;
1601}
1602
ef5ccd6c
JM
1603/* Provide a prototype to silence -Wmissing-prototypes. */
1604extern initialize_file_ftype _initialize_objc_lang;
1605
5796c8dc
SS
1606void
1607_initialize_objc_lang (void)
1608{
1609 objc_objfile_data = register_objfile_data ();
1610}