gdb/
[deliverable/binutils-gdb.git] / gdb / objc-lang.c
1 /* Objective-C language support routines for GDB, the GNU debugger.
2
3 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5
6 Contributed by Apple Computer, Inc.
7 Written by Michael Snyder.
8
9 This file is part of GDB.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23
24 #include "defs.h"
25 #include "symtab.h"
26 #include "gdbtypes.h"
27 #include "expression.h"
28 #include "parser-defs.h"
29 #include "language.h"
30 #include "c-lang.h"
31 #include "objc-lang.h"
32 #include "exceptions.h"
33 #include "complaints.h"
34 #include "value.h"
35 #include "symfile.h"
36 #include "objfiles.h"
37 #include "gdb_string.h" /* for strchr */
38 #include "target.h" /* for target_has_execution */
39 #include "gdbcore.h"
40 #include "gdbcmd.h"
41 #include "frame.h"
42 #include "gdb_regex.h"
43 #include "regcache.h"
44 #include "block.h"
45 #include "infcall.h"
46 #include "valprint.h"
47 #include "gdb_assert.h"
48
49 #include <ctype.h>
50
51 struct objc_object {
52 CORE_ADDR isa;
53 };
54
55 struct 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
68 struct objc_super {
69 CORE_ADDR receiver;
70 CORE_ADDR class;
71 };
72
73 struct objc_method {
74 CORE_ADDR name;
75 CORE_ADDR types;
76 CORE_ADDR imp;
77 };
78
79 static 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
85 struct symbol *
86 lookup_struct_typedef (char *name, struct block *block, int noerr)
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
110 CORE_ADDR
111 lookup_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 {
128 complaint (&symfile_complaints,
129 _("no way to lookup Objective-C classes"));
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
139 CORE_ADDR
140 lookup_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 {
157 complaint (&symfile_complaints,
158 _("no way to lookup Objective-C selectors"));
159 return 0;
160 }
161
162 selstring = value_coerce_array (value_string (selname,
163 strlen (selname) + 1,
164 char_type));
165 return value_as_long (call_function_by_hand (function, 1, &selstring));
166 }
167
168 struct value *
169 value_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
222 char *
223 objc_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 */
239 strcpy(cp, mangled+3); /* Tack on the rest of the mangled name. */
240
241 while (*cp && *cp == '_')
242 cp++; /* Skip any initial underbars in class
243 name. */
244
245 cp = strchr(cp, '_');
246 if (!cp) /* Find first non-initial underbar. */
247 {
248 xfree(demangled); /* not mangled name */
249 return NULL;
250 }
251 if (cp[1] == '_') /* Easy case: no category name. */
252 {
253 *cp++ = ' '; /* Replace two '_' with one ' '. */
254 strcpy(cp, mangled + (cp - demangled) + 2);
255 }
256 else
257 {
258 *cp++ = '('; /* Less easy case: category name. */
259 cp = strchr(cp, '_');
260 if (!cp)
261 {
262 xfree(demangled); /* not mangled name */
263 return NULL;
264 }
265 *cp++ = ')';
266 *cp++ = ' '; /* Overwriting 1st char of method name... */
267 strcpy(cp, mangled + (cp - demangled)); /* Get it back. */
268 }
269
270 while (*cp && *cp == '_')
271 cp++; /* Skip any initial underbars in
272 method name. */
273
274 for (; *cp; cp++)
275 if (*cp == '_')
276 *cp = ':'; /* Replace remaining '_' with ':'. */
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
286 /* Print the character C on STREAM as part of the contents of a
287 literal string whose delimiter is QUOTER. Note that that format
288 for printing characters and strings is language specific. */
289
290 static void
291 objc_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
292 {
293 c &= 0xFF; /* Avoid sign bit follies. */
294
295 if (PRINT_LITERAL_FORM (c))
296 {
297 if (c == '\\' || c == quoter)
298 {
299 fputs_filtered ("\\", stream);
300 }
301 fprintf_filtered (stream, "%c", c);
302 }
303 else
304 {
305 switch (c)
306 {
307 case '\n':
308 fputs_filtered ("\\n", stream);
309 break;
310 case '\b':
311 fputs_filtered ("\\b", stream);
312 break;
313 case '\t':
314 fputs_filtered ("\\t", stream);
315 break;
316 case '\f':
317 fputs_filtered ("\\f", stream);
318 break;
319 case '\r':
320 fputs_filtered ("\\r", stream);
321 break;
322 case '\033':
323 fputs_filtered ("\\e", stream);
324 break;
325 case '\007':
326 fputs_filtered ("\\a", stream);
327 break;
328 default:
329 fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
330 break;
331 }
332 }
333 }
334
335 static void
336 objc_printchar (int c, struct type *type, struct ui_file *stream)
337 {
338 fputs_filtered ("'", stream);
339 objc_emit_char (c, type, stream, '\'');
340 fputs_filtered ("'", stream);
341 }
342
343 /* Print the character string STRING, printing at most LENGTH
344 characters. Printing stops early if the number hits print_max;
345 repeat counts are printed as appropriate. Print ellipses at the
346 end if we had to stop before printing LENGTH characters, or if
347 FORCE_ELLIPSES. */
348
349 static void
350 objc_printstr (struct ui_file *stream, struct type *type,
351 const gdb_byte *string, unsigned int length,
352 const char *encoding, int force_ellipses,
353 const struct value_print_options *options)
354 {
355 unsigned int i;
356 unsigned int things_printed = 0;
357 int in_quotes = 0;
358 int need_comma = 0;
359
360 /* If the string was not truncated due to `set print elements', and
361 the last byte of it is a null, we don't print that, in
362 traditional C style. */
363 if ((!force_ellipses) && length > 0 && string[length-1] == '\0')
364 length--;
365
366 if (length == 0)
367 {
368 fputs_filtered ("\"\"", stream);
369 return;
370 }
371
372 for (i = 0; i < length && things_printed < options->print_max; ++i)
373 {
374 /* Position of the character we are examining to see whether it
375 is repeated. */
376 unsigned int rep1;
377 /* Number of repetitions we have detected so far. */
378 unsigned int reps;
379
380 QUIT;
381
382 if (need_comma)
383 {
384 fputs_filtered (", ", stream);
385 need_comma = 0;
386 }
387
388 rep1 = i + 1;
389 reps = 1;
390 while (rep1 < length && string[rep1] == string[i])
391 {
392 ++rep1;
393 ++reps;
394 }
395
396 if (reps > options->repeat_count_threshold)
397 {
398 if (in_quotes)
399 {
400 if (options->inspect_it)
401 fputs_filtered ("\\\", ", stream);
402 else
403 fputs_filtered ("\", ", stream);
404 in_quotes = 0;
405 }
406 objc_printchar (string[i], type, stream);
407 fprintf_filtered (stream, " <repeats %u times>", reps);
408 i = rep1 - 1;
409 things_printed += options->repeat_count_threshold;
410 need_comma = 1;
411 }
412 else
413 {
414 if (!in_quotes)
415 {
416 if (options->inspect_it)
417 fputs_filtered ("\\\"", stream);
418 else
419 fputs_filtered ("\"", stream);
420 in_quotes = 1;
421 }
422 objc_emit_char (string[i], type, stream, '"');
423 ++things_printed;
424 }
425 }
426
427 /* Terminate the quotes if necessary. */
428 if (in_quotes)
429 {
430 if (options->inspect_it)
431 fputs_filtered ("\\\"", stream);
432 else
433 fputs_filtered ("\"", stream);
434 }
435
436 if (force_ellipses || i < length)
437 fputs_filtered ("...", stream);
438 }
439
440 /* Determine if we are currently in the Objective-C dispatch function.
441 If so, get the address of the method function that the dispatcher
442 would call and use that as the function to step into instead. Also
443 skip over the trampoline for the function (if any). This is better
444 for the user since they are only interested in stepping into the
445 method function anyway. */
446 static CORE_ADDR
447 objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
448 {
449 struct gdbarch *gdbarch = get_frame_arch (frame);
450 CORE_ADDR real_stop_pc;
451 CORE_ADDR method_stop_pc;
452
453 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
454
455 if (real_stop_pc != 0)
456 find_objc_msgcall (real_stop_pc, &method_stop_pc);
457 else
458 find_objc_msgcall (stop_pc, &method_stop_pc);
459
460 if (method_stop_pc)
461 {
462 real_stop_pc = gdbarch_skip_trampoline_code
463 (gdbarch, frame, method_stop_pc);
464 if (real_stop_pc == 0)
465 real_stop_pc = method_stop_pc;
466 }
467
468 return real_stop_pc;
469 }
470
471
472 /* Table mapping opcodes into strings for printing operators
473 and precedences of the operators. */
474
475 static const struct op_print objc_op_print_tab[] =
476 {
477 {",", BINOP_COMMA, PREC_COMMA, 0},
478 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
479 {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
480 {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
481 {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
482 {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
483 {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
484 {"==", BINOP_EQUAL, PREC_EQUAL, 0},
485 {"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
486 {"<=", BINOP_LEQ, PREC_ORDER, 0},
487 {">=", BINOP_GEQ, PREC_ORDER, 0},
488 {">", BINOP_GTR, PREC_ORDER, 0},
489 {"<", BINOP_LESS, PREC_ORDER, 0},
490 {">>", BINOP_RSH, PREC_SHIFT, 0},
491 {"<<", BINOP_LSH, PREC_SHIFT, 0},
492 {"+", BINOP_ADD, PREC_ADD, 0},
493 {"-", BINOP_SUB, PREC_ADD, 0},
494 {"*", BINOP_MUL, PREC_MUL, 0},
495 {"/", BINOP_DIV, PREC_MUL, 0},
496 {"%", BINOP_REM, PREC_MUL, 0},
497 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
498 {"-", UNOP_NEG, PREC_PREFIX, 0},
499 {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
500 {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
501 {"*", UNOP_IND, PREC_PREFIX, 0},
502 {"&", UNOP_ADDR, PREC_PREFIX, 0},
503 {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
504 {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
505 {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
506 {NULL, OP_NULL, PREC_NULL, 0}
507 };
508
509 const struct language_defn objc_language_defn = {
510 "objective-c", /* Language name */
511 language_objc,
512 range_check_off,
513 type_check_off,
514 case_sensitive_on,
515 array_row_major,
516 macro_expansion_c,
517 &exp_descriptor_standard,
518 objc_parse,
519 objc_error,
520 null_post_parser,
521 objc_printchar, /* Print a character constant */
522 objc_printstr, /* Function to print string constant */
523 objc_emit_char,
524 c_print_type, /* Print a type using appropriate syntax */
525 c_print_typedef, /* Print a typedef using appropriate syntax */
526 c_val_print, /* Print a value using appropriate syntax */
527 c_value_print, /* Print a top-level value */
528 objc_skip_trampoline, /* Language specific skip_trampoline */
529 "self", /* name_of_this */
530 basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
531 basic_lookup_transparent_type,/* lookup_transparent_type */
532 objc_demangle, /* Language specific symbol demangler */
533 NULL, /* Language specific
534 class_name_from_physname */
535 objc_op_print_tab, /* Expression operators for printing */
536 1, /* C-style arrays */
537 0, /* String lower bound */
538 default_word_break_characters,
539 default_make_symbol_completion_list,
540 c_language_arch_info,
541 default_print_array_index,
542 default_pass_by_reference,
543 default_get_string,
544 LANG_MAGIC
545 };
546
547 /*
548 * ObjC:
549 * Following functions help construct Objective-C message calls.
550 */
551
552 struct selname /* For parsing Objective-C. */
553 {
554 struct selname *next;
555 char *msglist_sel;
556 int msglist_len;
557 };
558
559 static int msglist_len;
560 static struct selname *selname_chain;
561 static char *msglist_sel;
562
563 void
564 start_msglist(void)
565 {
566 struct selname *new =
567 (struct selname *) xmalloc (sizeof (struct selname));
568
569 new->next = selname_chain;
570 new->msglist_len = msglist_len;
571 new->msglist_sel = msglist_sel;
572 msglist_len = 0;
573 msglist_sel = (char *)xmalloc(1);
574 *msglist_sel = 0;
575 selname_chain = new;
576 }
577
578 void
579 add_msglist(struct stoken *str, int addcolon)
580 {
581 char *s, *p;
582 int len, plen;
583
584 if (str == 0) /* Unnamed arg, or... */
585 {
586 if (addcolon == 0) /* variable number of args. */
587 {
588 msglist_len++;
589 return;
590 }
591 p = "";
592 plen = 0;
593 }
594 else
595 {
596 p = str->ptr;
597 plen = str->length;
598 }
599 len = plen + strlen(msglist_sel) + 2;
600 s = (char *)xmalloc(len);
601 strcpy(s, msglist_sel);
602 strncat(s, p, plen);
603 xfree(msglist_sel);
604 msglist_sel = s;
605 if (addcolon)
606 {
607 s[len-2] = ':';
608 s[len-1] = 0;
609 msglist_len++;
610 }
611 else
612 s[len-2] = '\0';
613 }
614
615 int
616 end_msglist(void)
617 {
618 int val = msglist_len;
619 struct selname *sel = selname_chain;
620 char *p = msglist_sel;
621 CORE_ADDR selid;
622
623 selname_chain = sel->next;
624 msglist_len = sel->msglist_len;
625 msglist_sel = sel->msglist_sel;
626 selid = lookup_child_selector (parse_gdbarch, p);
627 if (!selid)
628 error (_("Can't find selector \"%s\""), p);
629 write_exp_elt_longcst (selid);
630 xfree(p);
631 write_exp_elt_longcst (val); /* Number of args */
632 xfree(sel);
633
634 return val;
635 }
636
637 /*
638 * Function: specialcmp (char *a, char *b)
639 *
640 * Special strcmp: treats ']' and ' ' as end-of-string.
641 * Used for qsorting lists of objc methods (either by class or selector).
642 */
643
644 static int
645 specialcmp (char *a, char *b)
646 {
647 while (*a && *a != ' ' && *a != ']' && *b && *b != ' ' && *b != ']')
648 {
649 if (*a != *b)
650 return *a - *b;
651 a++, b++;
652 }
653 if (*a && *a != ' ' && *a != ']')
654 return 1; /* a is longer therefore greater. */
655 if (*b && *b != ' ' && *b != ']')
656 return -1; /* a is shorter therefore lesser. */
657 return 0; /* a and b are identical. */
658 }
659
660 /*
661 * Function: compare_selectors (const void *, const void *)
662 *
663 * Comparison function for use with qsort. Arguments are symbols or
664 * msymbols Compares selector part of objc method name alphabetically.
665 */
666
667 static int
668 compare_selectors (const void *a, const void *b)
669 {
670 char *aname, *bname;
671
672 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
673 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
674 if (aname == NULL || bname == NULL)
675 error (_("internal: compare_selectors(1)"));
676
677 aname = strchr(aname, ' ');
678 bname = strchr(bname, ' ');
679 if (aname == NULL || bname == NULL)
680 error (_("internal: compare_selectors(2)"));
681
682 return specialcmp (aname+1, bname+1);
683 }
684
685 /*
686 * Function: selectors_info (regexp, from_tty)
687 *
688 * Implements the "Info selectors" command. Takes an optional regexp
689 * arg. Lists all objective c selectors that match the regexp. Works
690 * by grepping thru all symbols for objective c methods. Output list
691 * is sorted and uniqued.
692 */
693
694 static void
695 selectors_info (char *regexp, int from_tty)
696 {
697 struct objfile *objfile;
698 struct minimal_symbol *msymbol;
699 char *name;
700 char *val;
701 int matches = 0;
702 int maxlen = 0;
703 int ix;
704 char myregexp[2048];
705 char asel[256];
706 struct symbol **sym_arr;
707 int plusminus = 0;
708
709 if (regexp == NULL)
710 strcpy(myregexp, ".*]"); /* Null input, match all objc methods. */
711 else
712 {
713 if (*regexp == '+' || *regexp == '-')
714 { /* User wants only class methods or only instance methods. */
715 plusminus = *regexp++;
716 while (*regexp == ' ' || *regexp == '\t')
717 regexp++;
718 }
719 if (*regexp == '\0')
720 strcpy(myregexp, ".*]");
721 else
722 {
723 if (sizeof (myregexp) < strlen (regexp) + 1)
724 error (_("Regexp is too long: %s"), regexp);
725 strcpy(myregexp, regexp);
726 if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
727 myregexp[strlen(myregexp) - 1] = ']'; /* end of method name */
728 else
729 strcat(myregexp, ".*]");
730 }
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 {
749 /* Filter for class/instance methods. */
750 if (plusminus && name[0] != plusminus)
751 continue;
752 /* Find selector part. */
753 name = (char *) strchr(name+2, ' ');
754 if (regexp == NULL || re_exec(++name) != 0)
755 {
756 char *mystart = name;
757 char *myend = (char *) strchr(mystart, ']');
758
759 if (myend && (myend - mystart > maxlen))
760 maxlen = myend - mystart; /* Get longest selector. */
761 matches++;
762 }
763 }
764 }
765 if (matches)
766 {
767 printf_filtered (_("Selectors matching \"%s\":\n\n"),
768 regexp ? regexp : "*");
769
770 sym_arr = alloca (matches * sizeof (struct symbol *));
771 matches = 0;
772 ALL_MSYMBOLS (objfile, msymbol)
773 {
774 QUIT;
775 name = SYMBOL_NATURAL_NAME (msymbol);
776 if (name &&
777 (name[0] == '-' || name[0] == '+') &&
778 name[1] == '[') /* Got a method name. */
779 {
780 /* Filter for class/instance methods. */
781 if (plusminus && name[0] != plusminus)
782 continue;
783 /* Find selector part. */
784 name = (char *) strchr(name+2, ' ');
785 if (regexp == NULL || re_exec(++name) != 0)
786 sym_arr[matches++] = (struct symbol *) msymbol;
787 }
788 }
789
790 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
791 compare_selectors);
792 /* Prevent compare on first iteration. */
793 asel[0] = 0;
794 for (ix = 0; ix < matches; ix++) /* Now do the output. */
795 {
796 char *p = asel;
797
798 QUIT;
799 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
800 name = strchr (name, ' ') + 1;
801 if (p[0] && specialcmp(name, p) == 0)
802 continue; /* Seen this one already (not unique). */
803
804 /* Copy selector part. */
805 while (*name && *name != ']')
806 *p++ = *name++;
807 *p++ = '\0';
808 /* Print in columns. */
809 puts_filtered_tabular(asel, maxlen + 1, 0);
810 }
811 begin_line();
812 }
813 else
814 printf_filtered (_("No selectors matching \"%s\"\n"),
815 regexp ? regexp : "*");
816 }
817
818 /*
819 * Function: compare_classes (const void *, const void *)
820 *
821 * Comparison function for use with qsort. Arguments are symbols or
822 * msymbols Compares class part of objc method name alphabetically.
823 */
824
825 static int
826 compare_classes (const void *a, const void *b)
827 {
828 char *aname, *bname;
829
830 aname = SYMBOL_PRINT_NAME (*(struct symbol **) a);
831 bname = SYMBOL_PRINT_NAME (*(struct symbol **) b);
832 if (aname == NULL || bname == NULL)
833 error (_("internal: compare_classes(1)"));
834
835 return specialcmp (aname+1, bname+1);
836 }
837
838 /*
839 * Function: classes_info(regexp, from_tty)
840 *
841 * Implements the "info classes" command for objective c classes.
842 * Lists all objective c classes that match the optional regexp.
843 * Works by grepping thru the list of objective c methods. List will
844 * be sorted and uniqued (since one class may have many methods).
845 * BUGS: will not list a class that has no methods.
846 */
847
848 static void
849 classes_info (char *regexp, int from_tty)
850 {
851 struct objfile *objfile;
852 struct minimal_symbol *msymbol;
853 char *name;
854 char *val;
855 int matches = 0;
856 int maxlen = 0;
857 int ix;
858 char myregexp[2048];
859 char aclass[256];
860 struct symbol **sym_arr;
861
862 if (regexp == NULL)
863 strcpy(myregexp, ".* "); /* Null input: match all objc classes. */
864 else
865 {
866 strcpy(myregexp, regexp);
867 if (myregexp[strlen(myregexp) - 1] == '$')
868 /* In the method name, the end of the class name is marked by ' '. */
869 myregexp[strlen(myregexp) - 1] = ' ';
870 else
871 strcat(myregexp, ".* ");
872 }
873
874 if (regexp != NULL)
875 {
876 val = re_comp (myregexp);
877 if (val != 0)
878 error (_("Invalid regexp (%s): %s"), val, regexp);
879 }
880
881 /* First time thru is JUST to get max length and count. */
882 ALL_MSYMBOLS (objfile, msymbol)
883 {
884 QUIT;
885 name = SYMBOL_NATURAL_NAME (msymbol);
886 if (name &&
887 (name[0] == '-' || name[0] == '+') &&
888 name[1] == '[') /* Got a method name. */
889 if (regexp == NULL || re_exec(name+2) != 0)
890 {
891 /* Compute length of classname part. */
892 char *mystart = name + 2;
893 char *myend = (char *) strchr(mystart, ' ');
894
895 if (myend && (myend - mystart > maxlen))
896 maxlen = myend - mystart;
897 matches++;
898 }
899 }
900 if (matches)
901 {
902 printf_filtered (_("Classes matching \"%s\":\n\n"),
903 regexp ? regexp : "*");
904 sym_arr = alloca (matches * sizeof (struct symbol *));
905 matches = 0;
906 ALL_MSYMBOLS (objfile, msymbol)
907 {
908 QUIT;
909 name = SYMBOL_NATURAL_NAME (msymbol);
910 if (name &&
911 (name[0] == '-' || name[0] == '+') &&
912 name[1] == '[') /* Got a method name. */
913 if (regexp == NULL || re_exec(name+2) != 0)
914 sym_arr[matches++] = (struct symbol *) msymbol;
915 }
916
917 qsort (sym_arr, matches, sizeof (struct minimal_symbol *),
918 compare_classes);
919 /* Prevent compare on first iteration. */
920 aclass[0] = 0;
921 for (ix = 0; ix < matches; ix++) /* Now do the output. */
922 {
923 char *p = aclass;
924
925 QUIT;
926 name = SYMBOL_NATURAL_NAME (sym_arr[ix]);
927 name += 2;
928 if (p[0] && specialcmp(name, p) == 0)
929 continue; /* Seen this one already (not unique). */
930
931 /* Copy class part of method name. */
932 while (*name && *name != ' ')
933 *p++ = *name++;
934 *p++ = '\0';
935 /* Print in columns. */
936 puts_filtered_tabular(aclass, maxlen + 1, 0);
937 }
938 begin_line();
939 }
940 else
941 printf_filtered (_("No classes matching \"%s\"\n"), regexp ? regexp : "*");
942 }
943
944 /*
945 * Function: find_imps (char *selector, struct symbol **sym_arr)
946 *
947 * Input: a string representing a selector
948 * a pointer to an array of symbol pointers
949 * possibly a pointer to a symbol found by the caller.
950 *
951 * Output: number of methods that implement that selector. Side
952 * effects: The array of symbol pointers is filled with matching syms.
953 *
954 * By analogy with function "find_methods" (symtab.c), builds a list
955 * of symbols matching the ambiguous input, so that "decode_line_2"
956 * (symtab.c) can list them and ask the user to choose one or more.
957 * In this case the matches are objective c methods
958 * ("implementations") matching an objective c selector.
959 *
960 * Note that it is possible for a normal (c-style) function to have
961 * the same name as an objective c selector. To prevent the selector
962 * from eclipsing the function, we allow the caller (decode_line_1) to
963 * search for such a function first, and if it finds one, pass it in
964 * to us. We will then integrate it into the list. We also search
965 * for one here, among the minsyms.
966 *
967 * NOTE: if NUM_DEBUGGABLE is non-zero, the sym_arr will be divided
968 * into two parts: debuggable (struct symbol) syms, and
969 * non_debuggable (struct minimal_symbol) syms. The debuggable
970 * ones will come first, before NUM_DEBUGGABLE (which will thus
971 * be the index of the first non-debuggable one).
972 */
973
974 /*
975 * Function: total_number_of_imps (char *selector);
976 *
977 * Input: a string representing a selector
978 * Output: number of methods that implement that selector.
979 *
980 * By analogy with function "total_number_of_methods", this allows
981 * decode_line_1 (symtab.c) to detect if there are objective c methods
982 * matching the input, and to allocate an array of pointers to them
983 * which can be manipulated by "decode_line_2" (also in symtab.c).
984 */
985
986 char *
987 parse_selector (char *method, char **selector)
988 {
989 char *s1 = NULL;
990 char *s2 = NULL;
991 int found_quote = 0;
992
993 char *nselector = NULL;
994
995 gdb_assert (selector != NULL);
996
997 s1 = method;
998
999 while (isspace (*s1))
1000 s1++;
1001 if (*s1 == '\'')
1002 {
1003 found_quote = 1;
1004 s1++;
1005 }
1006 while (isspace (*s1))
1007 s1++;
1008
1009 nselector = s1;
1010 s2 = s1;
1011
1012 for (;;)
1013 {
1014 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1015 *s1++ = *s2;
1016 else if (isspace (*s2))
1017 ;
1018 else if ((*s2 == '\0') || (*s2 == '\''))
1019 break;
1020 else
1021 return NULL;
1022 s2++;
1023 }
1024 *s1++ = '\0';
1025
1026 while (isspace (*s2))
1027 s2++;
1028 if (found_quote)
1029 {
1030 if (*s2 == '\'')
1031 s2++;
1032 while (isspace (*s2))
1033 s2++;
1034 }
1035
1036 if (selector != NULL)
1037 *selector = nselector;
1038
1039 return s2;
1040 }
1041
1042 char *
1043 parse_method (char *method, char *type, char **class,
1044 char **category, char **selector)
1045 {
1046 char *s1 = NULL;
1047 char *s2 = NULL;
1048 int found_quote = 0;
1049
1050 char ntype = '\0';
1051 char *nclass = NULL;
1052 char *ncategory = NULL;
1053 char *nselector = NULL;
1054
1055 gdb_assert (type != NULL);
1056 gdb_assert (class != NULL);
1057 gdb_assert (category != NULL);
1058 gdb_assert (selector != NULL);
1059
1060 s1 = method;
1061
1062 while (isspace (*s1))
1063 s1++;
1064 if (*s1 == '\'')
1065 {
1066 found_quote = 1;
1067 s1++;
1068 }
1069 while (isspace (*s1))
1070 s1++;
1071
1072 if ((s1[0] == '+') || (s1[0] == '-'))
1073 ntype = *s1++;
1074
1075 while (isspace (*s1))
1076 s1++;
1077
1078 if (*s1 != '[')
1079 return NULL;
1080 s1++;
1081
1082 nclass = s1;
1083 while (isalnum (*s1) || (*s1 == '_'))
1084 s1++;
1085
1086 s2 = s1;
1087 while (isspace (*s2))
1088 s2++;
1089
1090 if (*s2 == '(')
1091 {
1092 s2++;
1093 while (isspace (*s2))
1094 s2++;
1095 ncategory = s2;
1096 while (isalnum (*s2) || (*s2 == '_'))
1097 s2++;
1098 *s2++ = '\0';
1099 }
1100
1101 /* Truncate the class name now that we're not using the open paren. */
1102 *s1++ = '\0';
1103
1104 nselector = s2;
1105 s1 = s2;
1106
1107 for (;;)
1108 {
1109 if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
1110 *s1++ = *s2;
1111 else if (isspace (*s2))
1112 ;
1113 else if (*s2 == ']')
1114 break;
1115 else
1116 return NULL;
1117 s2++;
1118 }
1119 *s1++ = '\0';
1120 s2++;
1121
1122 while (isspace (*s2))
1123 s2++;
1124 if (found_quote)
1125 {
1126 if (*s2 != '\'')
1127 return NULL;
1128 s2++;
1129 while (isspace (*s2))
1130 s2++;
1131 }
1132
1133 if (type != NULL)
1134 *type = ntype;
1135 if (class != NULL)
1136 *class = nclass;
1137 if (category != NULL)
1138 *category = ncategory;
1139 if (selector != NULL)
1140 *selector = nselector;
1141
1142 return s2;
1143 }
1144
1145 static void
1146 find_methods (struct symtab *symtab, char type,
1147 const char *class, const char *category,
1148 const char *selector, struct symbol **syms,
1149 unsigned int *nsym, unsigned int *ndebug)
1150 {
1151 struct objfile *objfile = NULL;
1152 struct minimal_symbol *msymbol = NULL;
1153 struct block *block = NULL;
1154 struct symbol *sym = NULL;
1155
1156 char *symname = NULL;
1157
1158 char ntype = '\0';
1159 char *nclass = NULL;
1160 char *ncategory = NULL;
1161 char *nselector = NULL;
1162
1163 unsigned int csym = 0;
1164 unsigned int cdebug = 0;
1165
1166 static char *tmp = NULL;
1167 static unsigned int tmplen = 0;
1168
1169 gdb_assert (nsym != NULL);
1170 gdb_assert (ndebug != NULL);
1171
1172 if (symtab)
1173 block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
1174
1175 ALL_OBJFILES (objfile)
1176 {
1177 unsigned int *objc_csym;
1178
1179 /* The objfile_csym variable counts the number of ObjC methods
1180 that this objfile defines. We save that count as a private
1181 objfile data. If we have already determined that this objfile
1182 provides no ObjC methods, we can skip it entirely. */
1183
1184 unsigned int objfile_csym = 0;
1185
1186 objc_csym = objfile_data (objfile, objc_objfile_data);
1187 if (objc_csym != NULL && *objc_csym == 0)
1188 /* There are no ObjC symbols in this objfile. Skip it entirely. */
1189 continue;
1190
1191 ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
1192 {
1193 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1194 CORE_ADDR pc = SYMBOL_VALUE_ADDRESS (msymbol);
1195
1196 QUIT;
1197
1198 /* Check the symbol name first as this can be done entirely without
1199 sending any query to the target. */
1200 symname = SYMBOL_NATURAL_NAME (msymbol);
1201 if (symname == NULL)
1202 continue;
1203
1204 if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
1205 /* Not a method name. */
1206 continue;
1207
1208 /* The minimal symbol might point to a function descriptor;
1209 resolve it to the actual code address instead. */
1210 pc = gdbarch_convert_from_func_ptr_addr (gdbarch, pc,
1211 &current_target);
1212
1213 if (symtab)
1214 if (pc < BLOCK_START (block) || pc >= BLOCK_END (block))
1215 /* Not in the specified symtab. */
1216 continue;
1217
1218 /* Now that thinks are a bit sane, clean up the symname. */
1219 while ((strlen (symname) + 1) >= tmplen)
1220 {
1221 tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
1222 tmp = xrealloc (tmp, tmplen);
1223 }
1224 strcpy (tmp, symname);
1225
1226 if (parse_method (tmp, &ntype, &nclass,
1227 &ncategory, &nselector) == NULL)
1228 continue;
1229
1230 objfile_csym++;
1231
1232 if ((type != '\0') && (ntype != type))
1233 continue;
1234
1235 if ((class != NULL)
1236 && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
1237 continue;
1238
1239 if ((category != NULL) &&
1240 ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
1241 continue;
1242
1243 if ((selector != NULL) &&
1244 ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
1245 continue;
1246
1247 sym = find_pc_function (pc);
1248 if (sym != NULL)
1249 {
1250 const char *newsymname = SYMBOL_NATURAL_NAME (sym);
1251
1252 if (strcmp (symname, newsymname) == 0)
1253 {
1254 /* Found a high-level method sym: swap it into the
1255 lower part of sym_arr (below num_debuggable). */
1256 if (syms != NULL)
1257 {
1258 syms[csym] = syms[cdebug];
1259 syms[cdebug] = sym;
1260 }
1261 csym++;
1262 cdebug++;
1263 }
1264 else
1265 {
1266 warning (
1267 "debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
1268 newsymname, symname);
1269 if (syms != NULL)
1270 syms[csym] = (struct symbol *) msymbol;
1271 csym++;
1272 }
1273 }
1274 else
1275 {
1276 /* Found a non-debuggable method symbol. */
1277 if (syms != NULL)
1278 syms[csym] = (struct symbol *) msymbol;
1279 csym++;
1280 }
1281 }
1282 if (objc_csym == NULL)
1283 {
1284 objc_csym = obstack_alloc (&objfile->objfile_obstack,
1285 sizeof (*objc_csym));
1286 *objc_csym = objfile_csym;
1287 set_objfile_data (objfile, objc_objfile_data, objc_csym);
1288 }
1289 else
1290 /* Count of ObjC methods in this objfile should be constant. */
1291 gdb_assert (*objc_csym == objfile_csym);
1292 }
1293
1294 if (nsym != NULL)
1295 *nsym = csym;
1296 if (ndebug != NULL)
1297 *ndebug = cdebug;
1298 }
1299
1300 char *find_imps (struct symtab *symtab, struct block *block,
1301 char *method, struct symbol **syms,
1302 unsigned int *nsym, unsigned int *ndebug)
1303 {
1304 char type = '\0';
1305 char *class = NULL;
1306 char *category = NULL;
1307 char *selector = NULL;
1308
1309 unsigned int csym = 0;
1310 unsigned int cdebug = 0;
1311
1312 unsigned int ncsym = 0;
1313 unsigned int ncdebug = 0;
1314
1315 char *buf = NULL;
1316 char *tmp = NULL;
1317
1318 gdb_assert (nsym != NULL);
1319 gdb_assert (ndebug != NULL);
1320
1321 if (nsym != NULL)
1322 *nsym = 0;
1323 if (ndebug != NULL)
1324 *ndebug = 0;
1325
1326 buf = (char *) alloca (strlen (method) + 1);
1327 strcpy (buf, method);
1328 tmp = parse_method (buf, &type, &class, &category, &selector);
1329
1330 if (tmp == NULL)
1331 {
1332 struct symbol *sym = NULL;
1333 struct minimal_symbol *msym = NULL;
1334
1335 strcpy (buf, method);
1336 tmp = parse_selector (buf, &selector);
1337
1338 if (tmp == NULL)
1339 return NULL;
1340
1341 sym = lookup_symbol (selector, block, VAR_DOMAIN, 0);
1342 if (sym != NULL)
1343 {
1344 if (syms)
1345 syms[csym] = sym;
1346 csym++;
1347 cdebug++;
1348 }
1349
1350 if (sym == NULL)
1351 msym = lookup_minimal_symbol (selector, 0, 0);
1352
1353 if (msym != NULL)
1354 {
1355 if (syms)
1356 syms[csym] = (struct symbol *)msym;
1357 csym++;
1358 }
1359 }
1360
1361 if (syms != NULL)
1362 find_methods (symtab, type, class, category, selector,
1363 syms + csym, &ncsym, &ncdebug);
1364 else
1365 find_methods (symtab, type, class, category, selector,
1366 NULL, &ncsym, &ncdebug);
1367
1368 /* If we didn't find any methods, just return. */
1369 if (ncsym == 0 && ncdebug == 0)
1370 return method;
1371
1372 /* Take debug symbols from the second batch of symbols and swap them
1373 * with debug symbols from the first batch. Repeat until either the
1374 * second section is out of debug symbols or the first section is
1375 * full of debug symbols. Either way we have all debug symbols
1376 * packed to the beginning of the buffer.
1377 */
1378
1379 if (syms != NULL)
1380 {
1381 while ((cdebug < csym) && (ncdebug > 0))
1382 {
1383 struct symbol *s = NULL;
1384 /* First non-debugging symbol. */
1385 unsigned int i = cdebug;
1386 /* Last of second batch of debug symbols. */
1387 unsigned int j = csym + ncdebug - 1;
1388
1389 s = syms[j];
1390 syms[j] = syms[i];
1391 syms[i] = s;
1392
1393 /* We've moved a symbol from the second debug section to the
1394 first one. */
1395 cdebug++;
1396 ncdebug--;
1397 }
1398 }
1399
1400 csym += ncsym;
1401 cdebug += ncdebug;
1402
1403 if (nsym != NULL)
1404 *nsym = csym;
1405 if (ndebug != NULL)
1406 *ndebug = cdebug;
1407
1408 if (syms == NULL)
1409 return method + (tmp - buf);
1410
1411 if (csym > 1)
1412 {
1413 /* Sort debuggable symbols. */
1414 if (cdebug > 1)
1415 qsort (syms, cdebug, sizeof (struct minimal_symbol *),
1416 compare_classes);
1417
1418 /* Sort minimal_symbols. */
1419 if ((csym - cdebug) > 1)
1420 qsort (&syms[cdebug], csym - cdebug,
1421 sizeof (struct minimal_symbol *), compare_classes);
1422 }
1423 /* Terminate the sym_arr list. */
1424 syms[csym] = 0;
1425
1426 return method + (tmp - buf);
1427 }
1428
1429 static void
1430 print_object_command (char *args, int from_tty)
1431 {
1432 struct value *object, *function, *description;
1433 CORE_ADDR string_addr, object_addr;
1434 int i = 0;
1435 gdb_byte c = 0;
1436
1437 if (!args || !*args)
1438 error (
1439 "The 'print-object' command requires an argument (an Objective-C object)");
1440
1441 {
1442 struct expression *expr = parse_expression (args);
1443 struct cleanup *old_chain =
1444 make_cleanup (free_current_contents, &expr);
1445 int pc = 0;
1446
1447 object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
1448 expr, &pc, EVAL_NORMAL);
1449 do_cleanups (old_chain);
1450 }
1451
1452 /* Validate the address for sanity. */
1453 object_addr = value_as_long (object);
1454 read_memory (object_addr, &c, 1);
1455
1456 function = find_function_in_inferior ("_NSPrintForDebugger", NULL);
1457 if (function == NULL)
1458 error (_("Unable to locate _NSPrintForDebugger in child process"));
1459
1460 description = call_function_by_hand (function, 1, &object);
1461
1462 string_addr = value_as_long (description);
1463 if (string_addr == 0)
1464 error (_("object returns null description"));
1465
1466 read_memory (string_addr + i++, &c, 1);
1467 if (c != 0)
1468 do
1469 { /* Read and print characters up to EOS. */
1470 QUIT;
1471 printf_filtered ("%c", c);
1472 read_memory (string_addr + i++, &c, 1);
1473 } while (c != 0);
1474 else
1475 printf_filtered(_("<object returns empty description>"));
1476 printf_filtered ("\n");
1477 }
1478
1479 /* The data structure 'methcalls' is used to detect method calls (thru
1480 * ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
1481 * and ultimately find the method being called.
1482 */
1483
1484 struct objc_methcall {
1485 char *name;
1486 /* Return instance method to be called. */
1487 int (*stop_at) (CORE_ADDR, CORE_ADDR *);
1488 /* Start of pc range corresponding to method invocation. */
1489 CORE_ADDR begin;
1490 /* End of pc range corresponding to method invocation. */
1491 CORE_ADDR end;
1492 };
1493
1494 static int resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc);
1495 static int resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1496 static int resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc);
1497 static int resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc);
1498
1499 static struct objc_methcall methcalls[] = {
1500 { "_objc_msgSend", resolve_msgsend, 0, 0},
1501 { "_objc_msgSend_stret", resolve_msgsend_stret, 0, 0},
1502 { "_objc_msgSendSuper", resolve_msgsend_super, 0, 0},
1503 { "_objc_msgSendSuper_stret", resolve_msgsend_super_stret, 0, 0},
1504 { "_objc_getClass", NULL, 0, 0},
1505 { "_objc_getMetaClass", NULL, 0, 0}
1506 };
1507
1508 #define nmethcalls (sizeof (methcalls) / sizeof (methcalls[0]))
1509
1510 /* The following function, "find_objc_msgsend", fills in the data
1511 * structure "objc_msgs" by finding the addresses of each of the
1512 * (currently four) functions that it holds (of which objc_msgSend is
1513 * the first). This must be called each time symbols are loaded, in
1514 * case the functions have moved for some reason.
1515 */
1516
1517 static void
1518 find_objc_msgsend (void)
1519 {
1520 unsigned int i;
1521
1522 for (i = 0; i < nmethcalls; i++)
1523 {
1524 struct minimal_symbol *func;
1525
1526 /* Try both with and without underscore. */
1527 func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
1528 if ((func == NULL) && (methcalls[i].name[0] == '_'))
1529 {
1530 func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
1531 }
1532 if (func == NULL)
1533 {
1534 methcalls[i].begin = 0;
1535 methcalls[i].end = 0;
1536 continue;
1537 }
1538
1539 methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
1540 do {
1541 methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
1542 } while (methcalls[i].begin == methcalls[i].end);
1543 }
1544 }
1545
1546 /* find_objc_msgcall (replaces pc_off_limits)
1547 *
1548 * ALL that this function now does is to determine whether the input
1549 * address ("pc") is the address of one of the Objective-C message
1550 * dispatch functions (mainly objc_msgSend or objc_msgSendSuper), and
1551 * if so, it returns the address of the method that will be called.
1552 *
1553 * The old function "pc_off_limits" used to do a lot of other things
1554 * in addition, such as detecting shared library jump stubs and
1555 * returning the address of the shlib function that would be called.
1556 * That functionality has been moved into the gdbarch_skip_trampoline_code and
1557 * IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
1558 * dependent modules.
1559 */
1560
1561 struct objc_submethod_helper_data {
1562 int (*f) (CORE_ADDR, CORE_ADDR *);
1563 CORE_ADDR pc;
1564 CORE_ADDR *new_pc;
1565 };
1566
1567 static int
1568 find_objc_msgcall_submethod_helper (void * arg)
1569 {
1570 struct objc_submethod_helper_data *s =
1571 (struct objc_submethod_helper_data *) arg;
1572
1573 if (s->f (s->pc, s->new_pc) == 0)
1574 return 1;
1575 else
1576 return 0;
1577 }
1578
1579 static int
1580 find_objc_msgcall_submethod (int (*f) (CORE_ADDR, CORE_ADDR *),
1581 CORE_ADDR pc,
1582 CORE_ADDR *new_pc)
1583 {
1584 struct objc_submethod_helper_data s;
1585
1586 s.f = f;
1587 s.pc = pc;
1588 s.new_pc = new_pc;
1589
1590 if (catch_errors (find_objc_msgcall_submethod_helper,
1591 (void *) &s,
1592 "Unable to determine target of "
1593 "Objective-C method call (ignoring):\n",
1594 RETURN_MASK_ALL) == 0)
1595 return 1;
1596 else
1597 return 0;
1598 }
1599
1600 int
1601 find_objc_msgcall (CORE_ADDR pc, CORE_ADDR *new_pc)
1602 {
1603 unsigned int i;
1604
1605 find_objc_msgsend ();
1606 if (new_pc != NULL)
1607 {
1608 *new_pc = 0;
1609 }
1610
1611 for (i = 0; i < nmethcalls; i++)
1612 if ((pc >= methcalls[i].begin) && (pc < methcalls[i].end))
1613 {
1614 if (methcalls[i].stop_at != NULL)
1615 return find_objc_msgcall_submethod (methcalls[i].stop_at,
1616 pc, new_pc);
1617 else
1618 return 0;
1619 }
1620
1621 return 0;
1622 }
1623
1624 /* -Wmissing-prototypes */
1625 extern initialize_file_ftype _initialize_objc_language;
1626
1627 void
1628 _initialize_objc_language (void)
1629 {
1630 add_language (&objc_language_defn);
1631 add_info ("selectors", selectors_info, /* INFO SELECTORS command. */
1632 _("All Objective-C selectors, or those matching REGEXP."));
1633 add_info ("classes", classes_info, /* INFO CLASSES command. */
1634 _("All Objective-C classes, or those matching REGEXP."));
1635 add_com ("print-object", class_vars, print_object_command,
1636 _("Ask an Objective-C object to print itself."));
1637 add_com_alias ("po", "print-object", class_vars, 1);
1638 }
1639
1640 static void
1641 read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1642 struct objc_method *method)
1643 {
1644 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1645
1646 method->name = read_memory_unsigned_integer (addr + 0, 4, byte_order);
1647 method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1648 method->imp = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1649 }
1650
1651 static unsigned long
1652 read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
1653 {
1654 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1655
1656 return read_memory_unsigned_integer (addr + 4, 4, byte_order);
1657 }
1658
1659 static void
1660 read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
1661 unsigned long num, struct objc_method *method)
1662 {
1663 gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
1664 read_objc_method (gdbarch, addr + 8 + (12 * num), method);
1665 }
1666
1667 static void
1668 read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
1669 struct objc_object *object)
1670 {
1671 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1672
1673 object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1674 }
1675
1676 static void
1677 read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
1678 struct objc_super *super)
1679 {
1680 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1681
1682 super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
1683 super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1684 };
1685
1686 static void
1687 read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
1688 struct objc_class *class)
1689 {
1690 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1691
1692 class->isa = read_memory_unsigned_integer (addr, 4, byte_order);
1693 class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
1694 class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
1695 class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
1696 class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
1697 class->instance_size = read_memory_unsigned_integer (addr + 18, 4,
1698 byte_order);
1699 class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
1700 class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
1701 class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
1702 class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
1703 }
1704
1705 static CORE_ADDR
1706 find_implementation_from_class (struct gdbarch *gdbarch,
1707 CORE_ADDR class, CORE_ADDR sel)
1708 {
1709 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1710 CORE_ADDR subclass = class;
1711
1712 while (subclass != 0)
1713 {
1714
1715 struct objc_class class_str;
1716 unsigned mlistnum = 0;
1717
1718 read_objc_class (gdbarch, subclass, &class_str);
1719
1720 for (;;)
1721 {
1722 CORE_ADDR mlist;
1723 unsigned long nmethods;
1724 unsigned long i;
1725
1726 mlist = read_memory_unsigned_integer (class_str.methods +
1727 (4 * mlistnum),
1728 4, byte_order);
1729 if (mlist == 0)
1730 break;
1731
1732 nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
1733
1734 for (i = 0; i < nmethods; i++)
1735 {
1736 struct objc_method meth_str;
1737
1738 read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
1739 #if 0
1740 fprintf (stderr,
1741 "checking method 0x%lx against selector 0x%lx\n",
1742 meth_str.name, sel);
1743 #endif
1744
1745 if (meth_str.name == sel)
1746 /* FIXME: hppa arch was doing a pointer dereference
1747 here. There needs to be a better way to do that. */
1748 return meth_str.imp;
1749 }
1750 mlistnum++;
1751 }
1752 subclass = class_str.super_class;
1753 }
1754
1755 return 0;
1756 }
1757
1758 static CORE_ADDR
1759 find_implementation (struct gdbarch *gdbarch,
1760 CORE_ADDR object, CORE_ADDR sel)
1761 {
1762 struct objc_object ostr;
1763
1764 if (object == 0)
1765 return 0;
1766 read_objc_object (gdbarch, object, &ostr);
1767 if (ostr.isa == 0)
1768 return 0;
1769
1770 return find_implementation_from_class (gdbarch, ostr.isa, sel);
1771 }
1772
1773 static int
1774 resolve_msgsend (CORE_ADDR pc, CORE_ADDR *new_pc)
1775 {
1776 struct frame_info *frame = get_current_frame ();
1777 struct gdbarch *gdbarch = get_frame_arch (frame);
1778 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1779
1780 CORE_ADDR object;
1781 CORE_ADDR sel;
1782 CORE_ADDR res;
1783
1784 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1785 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1786
1787 res = find_implementation (gdbarch, object, sel);
1788 if (new_pc != 0)
1789 *new_pc = res;
1790 if (res == 0)
1791 return 1;
1792 return 0;
1793 }
1794
1795 static int
1796 resolve_msgsend_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1797 {
1798 struct frame_info *frame = get_current_frame ();
1799 struct gdbarch *gdbarch = get_frame_arch (frame);
1800 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1801
1802 CORE_ADDR object;
1803 CORE_ADDR sel;
1804 CORE_ADDR res;
1805
1806 object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1807 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1808
1809 res = find_implementation (gdbarch, object, sel);
1810 if (new_pc != 0)
1811 *new_pc = res;
1812 if (res == 0)
1813 return 1;
1814 return 0;
1815 }
1816
1817 static int
1818 resolve_msgsend_super (CORE_ADDR pc, CORE_ADDR *new_pc)
1819 {
1820 struct frame_info *frame = get_current_frame ();
1821 struct gdbarch *gdbarch = get_frame_arch (frame);
1822 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1823
1824 struct objc_super sstr;
1825
1826 CORE_ADDR super;
1827 CORE_ADDR sel;
1828 CORE_ADDR res;
1829
1830 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
1831 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1832
1833 read_objc_super (gdbarch, super, &sstr);
1834 if (sstr.class == 0)
1835 return 0;
1836
1837 res = find_implementation_from_class (gdbarch, sstr.class, sel);
1838 if (new_pc != 0)
1839 *new_pc = res;
1840 if (res == 0)
1841 return 1;
1842 return 0;
1843 }
1844
1845 static int
1846 resolve_msgsend_super_stret (CORE_ADDR pc, CORE_ADDR *new_pc)
1847 {
1848 struct frame_info *frame = get_current_frame ();
1849 struct gdbarch *gdbarch = get_frame_arch (frame);
1850 struct type *ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
1851
1852 struct objc_super sstr;
1853
1854 CORE_ADDR super;
1855 CORE_ADDR sel;
1856 CORE_ADDR res;
1857
1858 super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
1859 sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
1860
1861 read_objc_super (gdbarch, super, &sstr);
1862 if (sstr.class == 0)
1863 return 0;
1864
1865 res = find_implementation_from_class (gdbarch, sstr.class, sel);
1866 if (new_pc != 0)
1867 *new_pc = res;
1868 if (res == 0)
1869 return 1;
1870 return 0;
1871 }
1872
1873 void
1874 _initialize_objc_lang (void)
1875 {
1876 objc_objfile_data = register_objfile_data ();
1877 }
This page took 0.109367 seconds and 5 git commands to generate.