/* Objective-C language support routines for GDB, the GNU debugger.
- Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008
+ Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
Free Software Foundation, Inc.
Contributed by Apple Computer, Inc.
CORE_ADDR imp;
};
+static const struct objfile_data *objc_objfile_data;
+
/* Lookup a structure type named "struct NAME", visible in lexical
block BLOCK. If NOERR is nonzero, return zero if NAME is not
suitably defined. */
}
CORE_ADDR
-lookup_objc_class (char *classname)
+lookup_objc_class (struct gdbarch *gdbarch, char *classname)
{
+ struct type *char_type = builtin_type (gdbarch)->builtin_char;
struct value * function, *classval;
if (! target_has_execution)
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;
}
- classval = value_string (classname, strlen (classname) + 1);
+ classval = value_string (classname, strlen (classname) + 1, char_type);
classval = value_coerce_array (classval);
return (CORE_ADDR) value_as_long (call_function_by_hand (function,
1, &classval));
}
CORE_ADDR
-lookup_child_selector (char *selname)
+lookup_child_selector (struct gdbarch *gdbarch, char *selname)
{
+ struct type *char_type = builtin_type (gdbarch)->builtin_char;
struct value * function, *selstring;
if (! target_has_execution)
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));
+ strlen (selname) + 1,
+ char_type));
return value_as_long (call_function_by_hand (function, 1, &selstring));
}
struct value *
-value_nsstring (char *ptr, int len)
+value_nsstring (struct gdbarch *gdbarch, char *ptr, int len)
{
+ struct type *char_type = builtin_type (gdbarch)->builtin_char;
struct value *stringValue[3];
struct value *function, *nsstringValue;
struct symbol *sym;
struct type *type;
- struct objfile *objf;
- struct gdbarch *gdbarch;
if (!target_has_execution)
return 0; /* Can't call into inferior to create NSString. */
- stringValue[2] = value_string(ptr, len);
+ stringValue[2] = value_string(ptr, len, char_type);
stringValue[2] = value_coerce_array(stringValue[2]);
/* _NSNewStringFromCString replaces "istr" after Lantern2A. */
if (lookup_minimal_symbol("_NSNewStringFromCString", 0, 0))
{
- function = find_function_in_inferior("_NSNewStringFromCString", &objf);
+ function = find_function_in_inferior("_NSNewStringFromCString", NULL);
nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
}
else if (lookup_minimal_symbol("istr", 0, 0))
{
- function = find_function_in_inferior("istr", &objf);
+ function = find_function_in_inferior("istr", NULL);
nsstringValue = call_function_by_hand(function, 1, &stringValue[2]);
}
else if (lookup_minimal_symbol("+[NSString stringWithCString:]", 0, 0))
{
function
- = find_function_in_inferior("+[NSString stringWithCString:]", &objf);
- type = builtin_type (get_objfile_arch (objf))->builtin_long;
+ = find_function_in_inferior("+[NSString stringWithCString:]", NULL);
+ type = builtin_type (gdbarch)->builtin_long;
stringValue[0] = value_from_longest
- (type, lookup_objc_class ("NSString"));
+ (type, lookup_objc_class (gdbarch, "NSString"));
stringValue[1] = value_from_longest
- (type, lookup_child_selector ("stringWithCString:"));
+ (type, lookup_child_selector (gdbarch, "stringWithCString:"));
nsstringValue = call_function_by_hand(function, 3, &stringValue[0]);
}
else
error (_("NSString: internal error -- no way to create new NSString"));
- gdbarch = get_objfile_arch (objf);
-
sym = lookup_struct_typedef("NSString", 0, 1);
if (sym == NULL)
sym = lookup_struct_typedef("NXString", 0, 1);
*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 */
for printing characters and strings is language specific. */
static void
-objc_emit_char (int c, struct ui_file *stream, int quoter)
+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_printchar (int c, struct ui_file *stream)
+objc_printchar (int c, struct type *type, struct ui_file *stream)
{
fputs_filtered ("'", stream);
- objc_emit_char (c, stream, '\'');
+ objc_emit_char (c, type, stream, '\'');
fputs_filtered ("'", stream);
}
FORCE_ELLIPSES. */
static void
-objc_printstr (struct ui_file *stream, const gdb_byte *string,
- unsigned int length, int width, int force_ellipses)
+objc_printstr (struct ui_file *stream, struct type *type,
+ const gdb_byte *string, unsigned int length,
+ const char *encoding, int force_ellipses,
+ const struct value_print_options *options)
{
unsigned int i;
unsigned int things_printed = 0;
return;
}
- for (i = 0; i < length && things_printed < print_max; ++i)
+ for (i = 0; i < length && things_printed < options->print_max; ++i)
{
/* Position of the character we are examining to see whether it
is repeated. */
++reps;
}
- if (reps > repeat_count_threshold)
+ if (reps > options->repeat_count_threshold)
{
if (in_quotes)
{
- if (inspect_it)
+ if (options->inspect_it)
fputs_filtered ("\\\", ", stream);
else
fputs_filtered ("\", ", stream);
in_quotes = 0;
}
- objc_printchar (string[i], stream);
+ objc_printchar (string[i], type, stream);
fprintf_filtered (stream, " <repeats %u times>", reps);
i = rep1 - 1;
- things_printed += repeat_count_threshold;
+ things_printed += options->repeat_count_threshold;
need_comma = 1;
}
else
{
if (!in_quotes)
{
- if (inspect_it)
+ if (options->inspect_it)
fputs_filtered ("\\\"", stream);
else
fputs_filtered ("\"", stream);
in_quotes = 1;
}
- objc_emit_char (string[i], stream, '"');
+ objc_emit_char (string[i], type, stream, '"');
++things_printed;
}
}
/* Terminate the quotes if necessary. */
if (in_quotes)
{
- if (inspect_it)
+ if (options->inspect_it)
fputs_filtered ("\\\"", stream);
else
fputs_filtered ("\"", stream);
/* 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. */
static CORE_ADDR
objc_skip_trampoline (struct frame_info *frame, CORE_ADDR stop_pc)
{
+ struct gdbarch *gdbarch = get_frame_arch (frame);
CORE_ADDR real_stop_pc;
CORE_ADDR method_stop_pc;
- real_stop_pc = gdbarch_skip_trampoline_code
- (current_gdbarch, frame, stop_pc);
+ real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc);
if (real_stop_pc != 0)
find_objc_msgcall (real_stop_pc, &method_stop_pc);
if (method_stop_pc)
{
real_stop_pc = gdbarch_skip_trampoline_code
- (current_gdbarch, frame, method_stop_pc);
+ (gdbarch, frame, method_stop_pc);
if (real_stop_pc == 0)
real_stop_pc = method_stop_pc;
}
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 */
c_language_arch_info,
default_print_array_index,
default_pass_by_reference,
+ default_get_string,
LANG_MAGIC
};
/*
* 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';
}
selname_chain = sel->next;
msglist_len = sel->msglist_len;
msglist_sel = sel->msglist_sel;
- selid = lookup_child_selector(p);
+ selid = lookup_child_selector (parse_gdbarch, p);
if (!selid)
error (_("Can't find selector \"%s\""), p);
write_exp_elt_longcst (selid);
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++;
if (symtab)
block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab), STATIC_BLOCK);
- ALL_MSYMBOLS (objfile, msymbol)
+ ALL_OBJFILES (objfile)
{
- QUIT;
+ unsigned int *objc_csym;
- if ((msymbol->type != mst_text) && (msymbol->type != mst_file_text))
- /* Not a function or method. */
- continue;
+ /* The objfile_csym variable counts the number of ObjC methods
+ that this objfile defines. We save that count as a private
+ objfile data. If we have already determined that this objfile
+ provides no ObjC methods, we can skip it entirely. */
- if (symtab)
- if ((SYMBOL_VALUE_ADDRESS (msymbol) < BLOCK_START (block)) ||
- (SYMBOL_VALUE_ADDRESS (msymbol) >= BLOCK_END (block)))
- /* Not in the specified symtab. */
- continue;
+ unsigned int objfile_csym = 0;
- symname = SYMBOL_NATURAL_NAME (msymbol);
- if (symname == NULL)
+ objc_csym = objfile_data (objfile, objc_objfile_data);
+ if (objc_csym != NULL && *objc_csym == 0)
+ /* There are no ObjC symbols in this objfile. Skip it entirely. */
continue;
- if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
- /* Not a method name. */
- continue;
-
- while ((strlen (symname) + 1) >= tmplen)
+ ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
{
- tmplen = (tmplen == 0) ? 1024 : tmplen * 2;
- tmp = xrealloc (tmp, tmplen);
- }
- strcpy (tmp, symname);
+ struct gdbarch *gdbarch = get_objfile_arch (objfile);
+ CORE_ADDR pc = SYMBOL_VALUE_ADDRESS (msymbol);
- if (parse_method (tmp, &ntype, &nclass, &ncategory, &nselector) == NULL)
- continue;
-
- if ((type != '\0') && (ntype != type))
- continue;
+ QUIT;
- if ((class != NULL)
- && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
- continue;
+ /* 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 ((category != NULL) &&
- ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
- continue;
+ if ((symname[0] != '-' && symname[0] != '+') || (symname[1] != '['))
+ /* Not a method name. */
+ continue;
- if ((selector != NULL) &&
- ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
- 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);
+
+ objfile_csym++;
+
+ 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;
+ tmp = xrealloc (tmp, tmplen);
+ }
+ strcpy (tmp, symname);
+
+ if (parse_method (tmp, &ntype, &nclass,
+ &ncategory, &nselector) == NULL)
+ continue;
+
+ if ((type != '\0') && (ntype != type))
+ continue;
+
+ if ((class != NULL)
+ && ((nclass == NULL) || (strcmp (class, nclass) != 0)))
+ continue;
+
+ if ((category != NULL) &&
+ ((ncategory == NULL) || (strcmp (category, ncategory) != 0)))
+ continue;
+
+ if ((selector != NULL) &&
+ ((nselector == NULL) || (strcmp (selector, nselector) != 0)))
+ continue;
- sym = find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol));
- if (sym != NULL)
- {
- const char *newsymname = SYMBOL_NATURAL_NAME (sym);
+ sym = find_pc_function (pc);
+ if (sym != NULL)
+ {
+ const char *newsymname = SYMBOL_NATURAL_NAME (sym);
- if (strcmp (symname, newsymname) == 0)
- {
- /* Found a high-level method sym: swap it into the
- lower part of sym_arr (below num_debuggable). */
- if (syms != NULL)
- {
- syms[csym] = syms[cdebug];
- syms[cdebug] = sym;
- }
- csym++;
- cdebug++;
- }
- else
- {
- warning (
+ if (strcmp (symname, newsymname) == 0)
+ {
+ /* Found a high-level method sym: swap it into the
+ lower part of sym_arr (below num_debuggable). */
+ if (syms != NULL)
+ {
+ syms[csym] = syms[cdebug];
+ syms[cdebug] = sym;
+ }
+ csym++;
+ cdebug++;
+ }
+ else
+ {
+ warning (
"debugging symbol \"%s\" does not match minimal symbol (\"%s\"); ignoring",
- newsymname, symname);
- if (syms != NULL)
- syms[csym] = (struct symbol *) msymbol;
- csym++;
- }
- }
- else
+ newsymname, symname);
+ if (syms != NULL)
+ syms[csym] = (struct symbol *) msymbol;
+ csym++;
+ }
+ }
+ else
+ {
+ /* Found a non-debuggable method symbol. */
+ if (syms != NULL)
+ syms[csym] = (struct symbol *) msymbol;
+ csym++;
+ }
+ }
+ if (objc_csym == NULL)
{
- /* Found a non-debuggable method symbol. */
- if (syms != NULL)
- syms[csym] = (struct symbol *) msymbol;
- csym++;
+ objc_csym = obstack_alloc (&objfile->objfile_obstack,
+ sizeof (*objc_csym));
+ *objc_csym = objfile_csym;
+ set_objfile_data (objfile, objc_objfile_data, objc_csym);
}
+ else
+ /* Count of ObjC methods in this objfile should be constant. */
+ gdb_assert (*objc_csym == objfile_csym);
}
if (nsym != NULL)
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)
return 1;
return 0;
}
+
+void
+_initialize_objc_lang (void)
+{
+ objc_objfile_data = register_objfile_data ();
+}