#include "demangle.h"
#include "complaints.h"
#include "gdbcmd.h"
+#include "wrapper.h"
/* These variables point to the objects
representing the predefined C data types. */
struct type *builtin_type_bfd_vma;
int opaque_type_resolution = 1;
-
+int overload_debug = 0;
struct extra
{
return (mtype);
}
-/* Allocate a stub method whose return type is TYPE.
+/* Allocate a stub method whose return type is TYPE.
This apparently happens for speed of symbol reading, since parsing
out the arguments to the method is cpu-intensive, the way we are doing
it. So, we will fill in arguments later.
case TYPE_CODE_CHAR:
*lowp = 0;
/* This round-about calculation is to avoid shifting by
- TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
- if TYPE_LENGTH (type) == sizeof (LONGEST). */
+ TYPE_LENGTH (type) * TARGET_CHAR_BIT, which will not work
+ if TYPE_LENGTH (type) == sizeof (LONGEST). */
*highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1);
*highp = (*highp - 1) | *highp;
return 0;
}
-/* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
+/* Smash TYPE to be a type of members of DOMAIN with type TO_TYPE.
A MEMBER is a wierd thing -- it amounts to a typed offset into
a struct, e.g. "an int at offset 8". A MEMBER TYPE doesn't
include the offset (that's the value of the MEMBER itself), but does
return TYPE_NAME (type);
}
-/* Lookup a primitive type named NAME.
+/* Lookup a primitive type named NAME.
Return zero if NAME is not a primitive type. */
struct type *
return (SYMBOL_TYPE (sym));
}
-/* Given a type TYPE, lookup the type of the component of type named NAME.
+/* Given a type TYPE, lookup the type of the component of type named NAME.
TYPE can be either a struct or union, or a pointer or reference to a struct or
union. If it is a pointer or reference, its target type is automatically used.
{
char *t_field_name = TYPE_FIELD_NAME (type, i);
- if (t_field_name && STREQ_IW (t_field_name, name))
+ if (t_field_name && (strcmp_iw (t_field_name, name) == 0))
{
return TYPE_FIELD_TYPE (type, i);
}
int i;
/* We must start at zero in case the first (and only) baseclass is
- virtual (and hence we cannot share the table pointer). */
+ virtual (and hence we cannot share the table pointer). */
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
fill_in_vptr_fieldno (TYPE_BASECLASS (type, i));
be a mistake, though--we might load in more symbols which contain a
full definition for the type.
- This used to be coded as a macro, but I don't think it is called
+ This used to be coded as a macro, but I don't think it is called
often enough to merit such treatment. */
struct complaint stub_noname_complaint =
{
char *name = type_name_no_tag (type);
/* FIXME: shouldn't we separately check the TYPE_NAME and the
- TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
- as appropriate? (this code was written before TYPE_NAME and
- TYPE_TAG_NAME were separate). */
+ TYPE_TAG_NAME, and look in STRUCT_NAMESPACE and/or VAR_NAMESPACE
+ as appropriate? (this code was written before TYPE_NAME and
+ TYPE_TAG_NAME were separate). */
struct symbol *sym;
if (name == NULL)
{
f = TYPE_FN_FIELDLIST1 (type, i); /* moved from below */
- /* kludge to support cfront methods - gdb expects to find "F" for
+ /* kludge to support cfront methods - gdb expects to find "F" for
ARM_mangled names, so when we mangle, we have to add it here */
if (ARM_DEMANGLING)
{
#undef ADD_EXTRA
/* End of new code added to support parsing of Cfront stabs strings */
+/* Parse a type expression in the string [P..P+LENGTH). If an error occurs,
+ silently return builtin_type_void. */
+
+struct type *
+safe_parse_type (char *p, int length)
+{
+ struct ui_file *saved_gdb_stderr;
+ struct type *type;
+
+ /* Suppress error messages. */
+ saved_gdb_stderr = gdb_stderr;
+ gdb_stderr = ui_file_new ();
+
+ /* Call parse_and_eval_type() without fear of longjmp()s. */
+ if (!gdb_parse_and_eval_type (p, length, &type))
+ type = builtin_type_void;
+
+ /* Stop suppressing error messages. */
+ ui_file_delete (gdb_stderr);
+ gdb_stderr = saved_gdb_stderr;
+
+ return type;
+}
+
/* Ugly hack to convert method stubs into method types.
He ain't kiddin'. This demangles the name of the method into a string
argtypetext = p;
while (*p)
{
- if (*p == '(')
+ if (*p == '(' || *p == '<')
{
depth += 1;
}
- else if (*p == ')')
+ else if (*p == ')' || *p == '>')
{
depth -= 1;
}
if (strncmp (argtypetext, "...", p - argtypetext) != 0)
{
argtypes[argcount] =
- parse_and_eval_type (argtypetext, p - argtypetext);
+ safe_parse_type (argtypetext, p - argtypetext);
argcount += 1;
}
argtypetext = p + 1;
}
- if (*p == '(')
+ if (*p == '(' || *p == '<')
{
depth += 1;
}
- else if (*p == ')')
+ else if (*p == ')' || *p == '>')
{
depth -= 1;
}
return 1;
}
-/* Check whether BASE is an ancestor or base class or DCLASS
+/* Check whether BASE is an ancestor or base class or DCLASS
Return 1 if so, and 0 if not.
Note: callers may want to check for identity of the types before
calling this function -- identical types are considered to satisfy
items. The vbasetype pointer of each item in the list points to the
type information for a virtual base of the argument DCLASS.
- Helper function for virtual_base_list().
+ Helper function for virtual_base_list().
Note: the list goes backward, right-to-left. virtual_base_list()
copies the items out in reverse order. */
LENGTH_MATCH (bv) = (nargs != nparms) ? LENGTH_MISMATCH_BADNESS : 0;
/* Now rank all the parameters of the candidate function */
- for (i = 1; i < min_len; i++)
- bv->rank[i] = rank_one_type (parms[i], args[i]);
+ for (i = 1; i <= min_len; i++)
+ bv->rank[i] = rank_one_type (parms[i-1], args[i-1]);
/* If more arguments than parameters, add dummy entries */
for (i = min_len + 1; i <= nargs; i++)
if (TYPE_CODE (arg) == TYPE_CODE_TYPEDEF)
arg = check_typedef (arg);
+ /*
+ Well, damnit, if the names are exactly the same,
+ i'll say they are exactly the same. This happens when we generate
+ method stubs. The types won't point to the same address, but they
+ really are the same.
+ */
+
+ if (TYPE_NAME (parm) == TYPE_NAME (arg))
+ return 0;
+
/* Check if identical after resolving typedefs */
if (parm == arg)
return 0;
- /* See through references, since we can almost make non-references references*/
+ /* See through references, since we can almost make non-references
+ references. */
if (TYPE_CODE (arg) == TYPE_CODE_REF)
- return rank_one_type(TYPE_TARGET_TYPE(arg),parm) + REFERENCE_CONVERSION_BADNESS;
+ return (rank_one_type (TYPE_TARGET_TYPE (arg), parm)
+ + REFERENCE_CONVERSION_BADNESS);
if (TYPE_CODE (parm) == TYPE_CODE_REF)
- return rank_one_type(arg,TYPE_TARGET_TYPE(parm)) + REFERENCE_CONVERSION_BADNESS;
-
-#ifdef DEBUG_OLOAD
- /* Debugging only */
- printf ("------ Arg is %s [%d], parm is %s [%d]\n",
- TYPE_NAME (arg), TYPE_CODE (arg), TYPE_NAME (parm), TYPE_CODE (parm));
-#endif
+ return (rank_one_type (arg, TYPE_TARGET_TYPE (parm))
+ + REFERENCE_CONVERSION_BADNESS);
+ if (overload_debug)
+ /* Debugging only. */
+ fprintf_filtered (gdb_stderr,"------ Arg is %s [%d], parm is %s [%d]\n",
+ TYPE_NAME (arg), TYPE_CODE (arg), TYPE_NAME (parm), TYPE_CODE (parm));
/* x -> y means arg of type x being supplied for parameter of type y */
if (TYPE_LENGTH (arg) == TYPE_LENGTH (parm))
{
/* Deal with signed, unsigned, and plain chars and
- signed and unsigned ints */
+ signed and unsigned ints */
if (TYPE_NOSIGN (parm))
{
/* This case only for character types */
default:
/* We have to pick one of the union types to be able print and test
- the value. Pick cplus_struct_type, even though we know it isn't
- any particular one. */
+ the value. Pick cplus_struct_type, even though we know it isn't
+ any particular one. */
printfi_filtered (spaces, "type_specific ");
gdb_print_host_address (TYPE_CPLUS_SPECIFIC (type), gdb_stdout);
if (TYPE_CPLUS_SPECIFIC (type) != NULL)
void
_initialize_gdbtypes ()
{
+ struct cmd_list_element *c;
build_gdbtypes ();
/* FIXME - For the moment, handle types by swapping them in and out.
REGISTER_GDBARCH_SWAP (builtin_type_CORE_ADDR);
REGISTER_GDBARCH_SWAP (builtin_type_bfd_vma);
register_gdbarch_swap (NULL, 0, build_gdbtypes);
+
+ add_show_from_set (
+ add_set_cmd ("overload", no_class, var_zinteger, (char *) &overload_debug,
+ "Set debugging of C++ overloading.\n\
+ When enabled, ranking of the functions\n\
+ is displayed.", &setdebuglist),
+ &showdebuglist);
}
projects / deliverable / binutils-gdb.git / blobdiff