GDB (xrefs)

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