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