/* Objective-C language support routines for GDB, the GNU debugger.
- Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009
+ Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
Contributed by Apple Computer, Inc.
function = find_function_in_inferior("objc_lookup_class", NULL);
else
{
- complaint (&symfile_complaints, _("no way to lookup Objective-C classes"));
+ complaint (&symfile_complaints,
+ _("no way to lookup Objective-C classes"));
return 0;
}
function = find_function_in_inferior("sel_get_any_uid", NULL);
else
{
- complaint (&symfile_complaints, _("no way to lookup Objective-C selectors"));
+ complaint (&symfile_complaints,
+ _("no way to lookup Objective-C selectors"));
return 0;
}
selstring = value_coerce_array (value_string (selname,
- strlen (selname) + 1, char_type));
+ strlen (selname) + 1,
+ char_type));
return value_as_long (call_function_by_hand (function, 1, &selstring));
}
*cp++ = '+'; /* for class method */
*cp++ = '['; /* opening left brace */
- strcpy(cp, mangled+3); /* tack on the rest of the mangled name */
+ strcpy(cp, mangled+3); /* Tack on the rest of the mangled name. */
while (*cp && *cp == '_')
- cp++; /* skip any initial underbars in class name */
+ cp++; /* Skip any initial underbars in class
+ name. */
cp = strchr(cp, '_');
- if (!cp) /* find first non-initial underbar */
+ if (!cp) /* Find first non-initial underbar. */
{
xfree(demangled); /* not mangled name */
return NULL;
}
- if (cp[1] == '_') { /* easy case: no category name */
- *cp++ = ' '; /* replace two '_' with one ' ' */
- strcpy(cp, mangled + (cp - demangled) + 2);
- }
- else {
- *cp++ = '('; /* less easy case: category name */
- cp = strchr(cp, '_');
- if (!cp)
- {
- xfree(demangled); /* not mangled name */
- return NULL;
- }
- *cp++ = ')';
- *cp++ = ' '; /* overwriting 1st char of method name... */
- strcpy(cp, mangled + (cp - demangled)); /* get it back */
- }
+ if (cp[1] == '_') /* Easy case: no category name. */
+ {
+ *cp++ = ' '; /* Replace two '_' with one ' '. */
+ strcpy(cp, mangled + (cp - demangled) + 2);
+ }
+ else
+ {
+ *cp++ = '('; /* Less easy case: category name. */
+ cp = strchr(cp, '_');
+ if (!cp)
+ {
+ xfree(demangled); /* not mangled name */
+ return NULL;
+ }
+ *cp++ = ')';
+ *cp++ = ' '; /* Overwriting 1st char of method name... */
+ strcpy(cp, mangled + (cp - demangled)); /* Get it back. */
+ }
while (*cp && *cp == '_')
- cp++; /* skip any initial underbars in method name */
+ cp++; /* Skip any initial underbars in
+ method name. */
for (; *cp; cp++)
if (*cp == '_')
- *cp = ':'; /* replace remaining '_' with ':' */
+ *cp = ':'; /* Replace remaining '_' with ':'. */
*cp++ = ']'; /* closing right brace */
*cp++ = 0; /* string terminator */
static void
objc_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
{
-
c &= 0xFF; /* Avoid sign bit follies. */
if (PRINT_LITERAL_FORM (c))
static void
objc_printstr (struct ui_file *stream, struct type *type,
const gdb_byte *string, unsigned int length,
- int force_ellipses,
+ const char *encoding, int force_ellipses,
const struct value_print_options *options)
{
unsigned int i;
unsigned int things_printed = 0;
int in_quotes = 0;
int need_comma = 0;
- int width = TYPE_LENGTH (type);
/* If the string was not truncated due to `set print elements', and
the last byte of it is a null, we don't print that, in
/* Determine if we are currently in the Objective-C dispatch function.
If so, get the address of the method function that the dispatcher
- would call and use that as the function to step into instead. Also
+ would call and use that as the function to step into instead. Also
skip over the trampoline for the function (if any). This is better
for the user since they are only interested in stepping into the
method function anyway. */
basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
basic_lookup_transparent_type,/* lookup_transparent_type */
objc_demangle, /* Language specific symbol demangler */
- NULL, /* Language specific class_name_from_physname */
+ NULL, /* Language specific
+ class_name_from_physname */
objc_op_print_tab, /* Expression operators for printing */
1, /* C-style arrays */
0, /* String lower bound */
/*
* ObjC:
- * Following functions help construct Objective-C message calls
+ * Following functions help construct Objective-C message calls.
*/
struct selname /* For parsing Objective-C. */
char *s, *p;
int len, plen;
- if (str == 0) { /* Unnamed arg, or... */
- if (addcolon == 0) { /* variable number of args. */
- msglist_len++;
- return;
+ if (str == 0) /* Unnamed arg, or... */
+ {
+ if (addcolon == 0) /* variable number of args. */
+ {
+ msglist_len++;
+ return;
+ }
+ p = "";
+ plen = 0;
+ }
+ else
+ {
+ p = str->ptr;
+ plen = str->length;
}
- p = "";
- plen = 0;
- } else {
- p = str->ptr;
- plen = str->length;
- }
len = plen + strlen(msglist_sel) + 2;
s = (char *)xmalloc(len);
strcpy(s, msglist_sel);
strncat(s, p, plen);
xfree(msglist_sel);
msglist_sel = s;
- if (addcolon) {
- s[len-2] = ':';
- s[len-1] = 0;
- msglist_len++;
- } else
+ if (addcolon)
+ {
+ s[len-2] = ':';
+ s[len-1] = 0;
+ msglist_len++;
+ }
+ else
s[len-2] = '\0';
}
a++, b++;
}
if (*a && *a != ' ' && *a != ']')
- return 1; /* a is longer therefore greater */
+ return 1; /* a is longer therefore greater. */
if (*b && *b != ' ' && *b != ']')
- return -1; /* a is shorter therefore lesser */
- return 0; /* a and b are identical */
+ return -1; /* a is shorter therefore lesser. */
+ return 0; /* a and b are identical. */
}
/*
strcpy(myregexp, ".*]");
else
{
+ /* Allow a few extra bytes because of the strcat below. */
+ if (sizeof (myregexp) < strlen (regexp) + 4)
+ error (_("Regexp is too long: %s"), regexp);
strcpy(myregexp, regexp);
if (myregexp[strlen(myregexp) - 1] == '$') /* end of selector */
myregexp[strlen(myregexp) - 1] = ']'; /* end of method name */
{
QUIT;
name = SYMBOL_NATURAL_NAME (msymbol);
- if (name &&
- (name[0] == '-' || name[0] == '+') &&
- name[1] == '[') /* Got a method name. */
+ if (name
+ && (name[0] == '-' || name[0] == '+')
+ && name[1] == '[') /* Got a method name. */
{
/* Filter for class/instance methods. */
if (plusminus && name[0] != plusminus)
continue;
/* Find selector part. */
- name = (char *) strchr(name+2, ' ');
+ name = (char *) strchr (name+2, ' ');
+ if (name == NULL)
+ {
+ complaint (&symfile_complaints,
+ _("Bad method name '%s'"),
+ SYMBOL_NATURAL_NAME (msymbol));
+ continue;
+ }
if (regexp == NULL || re_exec(++name) != 0)
{
char *mystart = name;
- char *myend = (char *) strchr(mystart, ']');
+ char *myend = (char *) strchr (mystart, ']');
if (myend && (myend - mystart > maxlen))
maxlen = myend - mystart; /* Get longest selector. */
begin_line();
}
else
- printf_filtered (_("No selectors matching \"%s\"\n"), regexp ? regexp : "*");
+ printf_filtered (_("No selectors matching \"%s\"\n"),
+ regexp ? regexp : "*");
}
/*
strcpy(myregexp, ".* "); /* Null input: match all objc classes. */
else
{
+ /* Allow a few extra bytes because of the strcat below. */
+ if (sizeof (myregexp) < strlen (regexp) + 4)
+ error (_("Regexp is too long: %s"), regexp);
strcpy(myregexp, regexp);
if (myregexp[strlen(myregexp) - 1] == '$')
/* In the method name, the end of the class name is marked by ' '. */
* into two parts: debuggable (struct symbol) syms, and
* non_debuggable (struct minimal_symbol) syms. The debuggable
* ones will come first, before NUM_DEBUGGABLE (which will thus
- * be the index of the first non-debuggable one).
+ * be the index of the first non-debuggable one).
*/
/*
nselector = s1;
s2 = s1;
- for (;;) {
- if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
- *s1++ = *s2;
- else if (isspace (*s2))
- ;
- else if ((*s2 == '\0') || (*s2 == '\''))
- break;
- else
- return NULL;
- s2++;
- }
+ for (;;)
+ {
+ if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
+ *s1++ = *s2;
+ else if (isspace (*s2))
+ ;
+ else if ((*s2 == '\0') || (*s2 == '\''))
+ break;
+ else
+ return NULL;
+ s2++;
+ }
*s1++ = '\0';
while (isspace (*s2))
nselector = s2;
s1 = s2;
- for (;;) {
- if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
- *s1++ = *s2;
- else if (isspace (*s2))
- ;
- else if (*s2 == ']')
- break;
- else
- return NULL;
- s2++;
- }
+ for (;;)
+ {
+ if (isalnum (*s2) || (*s2 == '_') || (*s2 == ':'))
+ *s1++ = *s2;
+ else if (isspace (*s2))
+ ;
+ else if (*s2 == ']')
+ break;
+ else
+ return NULL;
+ s2++;
+ }
*s1++ = '\0';
s2++;
ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
{
- QUIT;
-
- if ((MSYMBOL_TYPE (msymbol) != mst_text)
- && (MSYMBOL_TYPE (msymbol) != mst_file_text))
- /* Not a function or method. */
- continue;
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ CORE_ADDR pc = SYMBOL_VALUE_ADDRESS (msymbol);
- if (symtab)
- if ((SYMBOL_VALUE_ADDRESS (msymbol) < BLOCK_START (block)) ||
- (SYMBOL_VALUE_ADDRESS (msymbol) >= BLOCK_END (block)))
- /* Not in the specified symtab. */
- continue;
+ QUIT;
+ /* Check the symbol name first as this can be done entirely without
+ sending any query to the target. */
symname = SYMBOL_NATURAL_NAME (msymbol);
if (symname == NULL)
continue;
if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
/* Not a method name. */
continue;
-
+
+ /* The minimal symbol might point to a function descriptor;
+ resolve it to the actual code address instead. */
+ pc = gdbarch_convert_from_func_ptr_addr (gdbarch, pc,
+ ¤t_target);
+
+ if (symtab)
+ if (pc < BLOCK_START (block) || pc >= BLOCK_END (block))
+ /* Not in the specified symtab. */
+ continue;
+
+ /* Now that thinks are a bit sane, clean up the symname. */
while ((strlen (symname) + 1) >= tmplen)
{
tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
}
strcpy (tmp, symname);
- if (parse_method (tmp, &ntype, &nclass, &ncategory, &nselector) == NULL)
+ if (parse_method (tmp, &ntype, &nclass,
+ &ncategory, &nselector) == NULL)
continue;
objfile_csym++;
((nselector == NULL) || (strcmp (selector, nselector) != 0)))
continue;
- sym = find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol));
+ sym = find_pc_function (pc);
if (sym != NULL)
{
const char *newsymname = SYMBOL_NATURAL_NAME (sym);
strcpy (buf, method);
tmp = parse_method (buf, &type, &class, &category, &selector);
- if (tmp == NULL) {
-
- struct symbol *sym = NULL;
- struct minimal_symbol *msym = NULL;
-
- strcpy (buf, method);
- tmp = parse_selector (buf, &selector);
-
- if (tmp == NULL)
- return NULL;
-
- sym = lookup_symbol (selector, block, VAR_DOMAIN, 0);
- if (sym != NULL)
- {
- if (syms)
- syms[csym] = sym;
- csym++;
- cdebug++;
- }
+ if (tmp == NULL)
+ {
+ struct symbol *sym = NULL;
+ struct minimal_symbol *msym = NULL;
- if (sym == NULL)
- msym = lookup_minimal_symbol (selector, 0, 0);
+ strcpy (buf, method);
+ tmp = parse_selector (buf, &selector);
- if (msym != NULL)
- {
- if (syms)
- syms[csym] = (struct symbol *)msym;
- csym++;
- }
- }
+ if (tmp == NULL)
+ return NULL;
+
+ sym = lookup_symbol (selector, block, VAR_DOMAIN, 0);
+ if (sym != NULL)
+ {
+ if (syms)
+ syms[csym] = sym;
+ csym++;
+ cdebug++;
+ }
+
+ if (sym == NULL)
+ msym = lookup_minimal_symbol (selector, 0, 0);
+
+ if (msym != NULL)
+ {
+ if (syms)
+ syms[csym] = (struct symbol *)msym;
+ csym++;
+ }
+ }
if (syms != NULL)
find_methods (symtab, type, class, category, selector,
* with debug symbols from the first batch. Repeat until either the
* second section is out of debug symbols or the first section is
* full of debug symbols. Either way we have all debug symbols
- * packed to the beginning of the buffer.
+ * packed to the beginning of the buffer.
*/
if (syms != NULL)
make_cleanup (free_current_contents, &expr);
int pc = 0;
- object = expr->language_defn->la_exp_desc->evaluate_exp
- (builtin_type (expr->gdbarch)->builtin_data_ptr, expr, &pc, EVAL_NORMAL);
+ object = evaluate_subexp (builtin_type (expr->gdbarch)->builtin_data_ptr,
+ expr, &pc, EVAL_NORMAL);
do_cleanups (old_chain);
}
/* The data structure 'methcalls' is used to detect method calls (thru
* ObjC runtime lib functions objc_msgSend, objc_msgSendSuper, etc.),
- * and ultimately find the method being called.
+ * and ultimately find the method being called.
*/
struct objc_methcall {
* structure "objc_msgs" by finding the addresses of each of the
* (currently four) functions that it holds (of which objc_msgSend is
* the first). This must be called each time symbols are loaded, in
- * case the functions have moved for some reason.
+ * case the functions have moved for some reason.
*/
static void
find_objc_msgsend (void)
{
unsigned int i;
- for (i = 0; i < nmethcalls; i++) {
- struct minimal_symbol *func;
+ for (i = 0; i < nmethcalls; i++)
+ {
+ struct minimal_symbol *func;
- /* Try both with and without underscore. */
- func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
- if ((func == NULL) && (methcalls[i].name[0] == '_')) {
- func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
- }
- if (func == NULL) {
- methcalls[i].begin = 0;
- methcalls[i].end = 0;
- continue;
+ /* Try both with and without underscore. */
+ func = lookup_minimal_symbol (methcalls[i].name, NULL, NULL);
+ if ((func == NULL) && (methcalls[i].name[0] == '_'))
+ {
+ func = lookup_minimal_symbol (methcalls[i].name + 1, NULL, NULL);
+ }
+ if (func == NULL)
+ {
+ methcalls[i].begin = 0;
+ methcalls[i].end = 0;
+ continue;
+ }
+
+ methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
+ do {
+ methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
+ } while (methcalls[i].begin == methcalls[i].end);
}
-
- methcalls[i].begin = SYMBOL_VALUE_ADDRESS (func);
- do {
- methcalls[i].end = SYMBOL_VALUE_ADDRESS (++func);
- } while (methcalls[i].begin == methcalls[i].end);
- }
}
/* find_objc_msgcall (replaces pc_off_limits)
* returning the address of the shlib function that would be called.
* That functionality has been moved into the gdbarch_skip_trampoline_code and
* IN_SOLIB_TRAMPOLINE macros, which are resolved in the target-
- * dependent modules.
+ * dependent modules.
*/
struct objc_submethod_helper_data {
if (catch_errors (find_objc_msgcall_submethod_helper,
(void *) &s,
- "Unable to determine target of Objective-C method call (ignoring):\n",
+ "Unable to determine target of "
+ "Objective-C method call (ignoring):\n",
RETURN_MASK_ALL) == 0)
return 1;
else
return 0;
}
-extern initialize_file_ftype _initialize_objc_language; /* -Wmissing-prototypes */
+/* -Wmissing-prototypes */
+extern initialize_file_ftype _initialize_objc_language;
void
_initialize_objc_language (void)
}
static void
-read_objc_method (CORE_ADDR addr, struct objc_method *method)
+read_objc_method (struct gdbarch *gdbarch, CORE_ADDR addr,
+ struct objc_method *method)
{
- method->name = read_memory_unsigned_integer (addr + 0, 4);
- method->types = read_memory_unsigned_integer (addr + 4, 4);
- method->imp = read_memory_unsigned_integer (addr + 8, 4);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+ method->name = read_memory_unsigned_integer (addr + 0, 4, byte_order);
+ method->types = read_memory_unsigned_integer (addr + 4, 4, byte_order);
+ method->imp = read_memory_unsigned_integer (addr + 8, 4, byte_order);
}
-static
-unsigned long read_objc_methlist_nmethods (CORE_ADDR addr)
+static unsigned long
+read_objc_methlist_nmethods (struct gdbarch *gdbarch, CORE_ADDR addr)
{
- return read_memory_unsigned_integer (addr + 4, 4);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+ return read_memory_unsigned_integer (addr + 4, 4, byte_order);
}
static void
-read_objc_methlist_method (CORE_ADDR addr, unsigned long num,
- struct objc_method *method)
+read_objc_methlist_method (struct gdbarch *gdbarch, CORE_ADDR addr,
+ unsigned long num, struct objc_method *method)
{
- gdb_assert (num < read_objc_methlist_nmethods (addr));
- read_objc_method (addr + 8 + (12 * num), method);
+ gdb_assert (num < read_objc_methlist_nmethods (gdbarch, addr));
+ read_objc_method (gdbarch, addr + 8 + (12 * num), method);
}
static void
-read_objc_object (CORE_ADDR addr, struct objc_object *object)
+read_objc_object (struct gdbarch *gdbarch, CORE_ADDR addr,
+ struct objc_object *object)
{
- object->isa = read_memory_unsigned_integer (addr, 4);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+ object->isa = read_memory_unsigned_integer (addr, 4, byte_order);
}
static void
-read_objc_super (CORE_ADDR addr, struct objc_super *super)
+read_objc_super (struct gdbarch *gdbarch, CORE_ADDR addr,
+ struct objc_super *super)
{
- super->receiver = read_memory_unsigned_integer (addr, 4);
- super->class = read_memory_unsigned_integer (addr + 4, 4);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+ super->receiver = read_memory_unsigned_integer (addr, 4, byte_order);
+ super->class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
};
static void
-read_objc_class (CORE_ADDR addr, struct objc_class *class)
+read_objc_class (struct gdbarch *gdbarch, CORE_ADDR addr,
+ struct objc_class *class)
{
- class->isa = read_memory_unsigned_integer (addr, 4);
- class->super_class = read_memory_unsigned_integer (addr + 4, 4);
- class->name = read_memory_unsigned_integer (addr + 8, 4);
- class->version = read_memory_unsigned_integer (addr + 12, 4);
- class->info = read_memory_unsigned_integer (addr + 16, 4);
- class->instance_size = read_memory_unsigned_integer (addr + 18, 4);
- class->ivars = read_memory_unsigned_integer (addr + 24, 4);
- class->methods = read_memory_unsigned_integer (addr + 28, 4);
- class->cache = read_memory_unsigned_integer (addr + 32, 4);
- class->protocols = read_memory_unsigned_integer (addr + 36, 4);
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+
+ class->isa = read_memory_unsigned_integer (addr, 4, byte_order);
+ class->super_class = read_memory_unsigned_integer (addr + 4, 4, byte_order);
+ class->name = read_memory_unsigned_integer (addr + 8, 4, byte_order);
+ class->version = read_memory_unsigned_integer (addr + 12, 4, byte_order);
+ class->info = read_memory_unsigned_integer (addr + 16, 4, byte_order);
+ class->instance_size = read_memory_unsigned_integer (addr + 18, 4,
+ byte_order);
+ class->ivars = read_memory_unsigned_integer (addr + 24, 4, byte_order);
+ class->methods = read_memory_unsigned_integer (addr + 28, 4, byte_order);
+ class->cache = read_memory_unsigned_integer (addr + 32, 4, byte_order);
+ class->protocols = read_memory_unsigned_integer (addr + 36, 4, byte_order);
}
static CORE_ADDR
-find_implementation_from_class (CORE_ADDR class, CORE_ADDR sel)
+find_implementation_from_class (struct gdbarch *gdbarch,
+ CORE_ADDR class, CORE_ADDR sel)
{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
CORE_ADDR subclass = class;
while (subclass != 0)
struct objc_class class_str;
unsigned mlistnum = 0;
- read_objc_class (subclass, &class_str);
+ read_objc_class (gdbarch, subclass, &class_str);
for (;;)
{
unsigned long i;
mlist = read_memory_unsigned_integer (class_str.methods +
- (4 * mlistnum), 4);
+ (4 * mlistnum),
+ 4, byte_order);
if (mlist == 0)
break;
- nmethods = read_objc_methlist_nmethods (mlist);
+ nmethods = read_objc_methlist_nmethods (gdbarch, mlist);
for (i = 0; i < nmethods; i++)
{
struct objc_method meth_str;
- read_objc_methlist_method (mlist, i, &meth_str);
+ read_objc_methlist_method (gdbarch, mlist, i, &meth_str);
#if 0
fprintf (stderr,
"checking method 0x%lx against selector 0x%lx\n",
if (meth_str.name == sel)
/* FIXME: hppa arch was doing a pointer dereference
- here. There needs to be a better way to do that. */
+ here. There needs to be a better way to do that. */
return meth_str.imp;
}
mlistnum++;
}
static CORE_ADDR
-find_implementation (CORE_ADDR object, CORE_ADDR sel)
+find_implementation (struct gdbarch *gdbarch,
+ CORE_ADDR object, CORE_ADDR sel)
{
struct objc_object ostr;
if (object == 0)
return 0;
- read_objc_object (object, &ostr);
+ read_objc_object (gdbarch, object, &ostr);
if (ostr.isa == 0)
return 0;
- return find_implementation_from_class (ostr.isa, sel);
+ return find_implementation_from_class (gdbarch, ostr.isa, sel);
}
static int
object = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
- res = find_implementation (object, sel);
+ res = find_implementation (gdbarch, object, sel);
if (new_pc != 0)
*new_pc = res;
if (res == 0)
object = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
- res = find_implementation (object, sel);
+ res = find_implementation (gdbarch, object, sel);
if (new_pc != 0)
*new_pc = res;
if (res == 0)
super = gdbarch_fetch_pointer_argument (gdbarch, frame, 0, ptr_type);
sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
- read_objc_super (super, &sstr);
+ read_objc_super (gdbarch, super, &sstr);
if (sstr.class == 0)
return 0;
- res = find_implementation_from_class (sstr.class, sel);
+ res = find_implementation_from_class (gdbarch, sstr.class, sel);
if (new_pc != 0)
*new_pc = res;
if (res == 0)
super = gdbarch_fetch_pointer_argument (gdbarch, frame, 1, ptr_type);
sel = gdbarch_fetch_pointer_argument (gdbarch, frame, 2, ptr_type);
- read_objc_super (super, &sstr);
+ read_objc_super (gdbarch, super, &sstr);
if (sstr.class == 0)
return 0;
- res = find_implementation_from_class (sstr.class, sel);
+ res = find_implementation_from_class (gdbarch, sstr.class, sel);
if (new_pc != 0)
*new_pc = res;
if (res == 0)
projects / deliverable / binutils-gdb.git / blobdiff