This is the mail archive of the
gdb-patches@sourceware.cygnus.com
mailing list for the GDB project.
Even better C++ support coming soon, to a GDB near you
- To: gdb-patches at sourceware dot cygnus dot com
- Subject: Even better C++ support coming soon, to a GDB near you
- From: dan at cgsoftware dot com (Daniel Berlin)
- Date: 29 Mar 2000 23:36:36 -0500
- Reply-To: dan at cgsoftware dot com
I'll be applying the attached, along with testsuite cases (They will
be handled seperately, as I want to run them past some folks, as they are my
first set of "from scratch" test cases, and i want to make sure i
haven't screwed up), sometime tomorrow.
It causes no regressions, and literally only affects C++ support (The
code paths don't get touched outside of C++ programs), so don't let
the fact that it spreads across files scare you. It comprises 3 bug
fixes, and 1 new feature. (all the bug fixes were done tonight, which
is why they aren't separate patches).
I think we pass a few more tests now as well, but you won't see the
real effect until my new testcases get committed.
Advantages:
RTTI for g++. If you turn on set print object, you'll get RTTI.
STABS c++ overloading improved again. No longer do we get screwed
trying to find stabs overloads by methods unrelated to the overload at
hand (before, we were check_method_stub'ing every possible method,
which invariable gives us an error on some hairy
*internal-to-the-class method* that nobody ever calls, but the error
routine stopped the entire overload lookup dead in it's tracks. Now we
only check_method_stub those overloads that could possibly be related,
so as long as you weren't trying to call the nasty
*internal-to-the-class* method, you won't get bitten.
STABS c++ handling improved in general. You won't get screwed by
templates anymore (it would get the arguments wrong, mainly in method
stubbing, because it wasn't accounting for templates.
Miscellaneous fixes to C++ evaluation, adding RTTI where it was
needed, fixing some offsets,etc.
As the changelog shows, this is really 4 sets of patches (1 blank line
in between each set).
I just happen to be committing them all the same day.
I'm saving really major changes till the 5.0 branch is cut (much
better RTTI is in the works, and exception handling for new style, and
SJLJ, exceptions).
As i've said, i'm quite sure this can't affect anything but C++
support, but i don't want to cause a ruckus, so if anyone has any
problems with me committing it, feel free to yell.
I can seperate out the RTTI vs non-RTTI stuff, but it would be
painful (which is the only reason i didn't, i'd most likely screw up
and we'd end up with broken code). If someone feels it should be done,
i'll make it so, however.
--Dan
Index: typeprint.c
===================================================================
RCS file: /cvs/src/src/gdb/typeprint.c,v
retrieving revision 1.1.1.5
diff -c -3 -p -b -B -w -r1.1.1.5 typeprint.c
*** typeprint.c 2000/02/02 00:21:11 1.1.1.5
--- typeprint.c 2000/03/30 04:33:37
*************** whatis_exp (exp, show)
*** 82,87 ****
--- 82,88 ----
register value_ptr val;
register struct cleanup *old_chain = NULL;
struct type *real_type = NULL;
+ struct type *type;
int full = 0;
int top = -1;
int using_enc = 0;
*************** whatis_exp (exp, show)
*** 96,112 ****
else
val = access_value_history (0);
real_type = value_rtti_type (val, &full, &top, &using_enc);
printf_filtered ("type = ");
! if (real_type && objectprint)
! printf_filtered ("/* real type = %s%s */\n",
! TYPE_NAME (real_type),
! full ? "" : " (incomplete object)");
! /* FIXME: maybe better to use type_print (real_type, "", gdb_stdout, -1); */
! type_print (VALUE_TYPE (val), "", gdb_stdout, show);
printf_filtered ("\n");
if (exp)
--- 97,136 ----
else
val = access_value_history (0);
+ type = VALUE_TYPE (val);
+
+ if (objectprint)
+ {
+ if (((TYPE_CODE (type) == TYPE_CODE_PTR) ||
+ (TYPE_CODE (type) == TYPE_CODE_REF))
+ &&
+ (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
+ {
+ real_type = value_rtti_target_type (val, &full, &top, &using_enc);
+ if (real_type)
+ {
+ if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ real_type = lookup_pointer_type (real_type);
+ else
+ real_type = lookup_reference_type (real_type);
+ }
+ }
+ else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
real_type = value_rtti_type (val, &full, &top, &using_enc);
+ }
printf_filtered ("type = ");
! if (real_type)
! {
! printf_filtered ("/* real type = ");
! type_print (real_type, "", gdb_stdout, -1);
! if (! full)
! printf_filtered (" (incomplete object)");
! printf_filtered (" */\n");
! }
! type_print (type, "", gdb_stdout, show);
printf_filtered ("\n");
if (exp)
Index: eval.c
===================================================================
RCS file: /cvs/src/src/gdb/eval.c,v
retrieving revision 1.2
diff -c -3 -p -b -B -w -r1.2 eval.c
*** eval.c 2000/03/14 17:01:04 1.2
--- eval.c 2000/03/30 04:33:38
*************** extern int hp_som_som_object_present;
*** 37,42 ****
--- 37,45 ----
/* This is defined in valops.c */
extern int overload_resolution;
+ /* JYG: lookup rtti type of STRUCTOP_PTR when this is set to continue
+ on with successful lookup for member/method of the rtti type. */
+ extern int objectprint;
/* Prototypes for local functions. */
*************** evaluate_subexp_standard (expect_type, e
*** 428,459 ****
(*pos) += 3;
if (noside == EVAL_SKIP)
goto nosideret;
- if (noside == EVAL_AVOID_SIDE_EFFECTS)
- {
- struct symbol *sym = exp->elts[pc + 2].symbol;
- enum lval_type lv;
-
- switch (SYMBOL_CLASS (sym))
- {
- case LOC_CONST:
- case LOC_LABEL:
- case LOC_CONST_BYTES:
- lv = not_lval;
- break;
! case LOC_REGISTER:
! case LOC_REGPARM:
! lv = lval_register;
! break;
- default:
- lv = lval_memory;
- break;
- }
-
- return value_zero (SYMBOL_TYPE (sym), lv);
- }
- else
return value_of_variable (exp->elts[pc + 2].symbol,
exp->elts[pc + 1].block);
--- 431,446 ----
(*pos) += 3;
if (noside == EVAL_SKIP)
goto nosideret;
! /* JYG: We used to just return value_zero of the symbol type
! if we're asked to avoid side effects. Otherwise we return
! value_of_variable (...). However I'm not sure if
! value_of_variable () has any side effect.
! We need a full value object returned here for whatis_exp ()
! to call evaluate_type () and then pass the full value to
! value_rtti_target_type () if we are dealing with a pointer
! or reference to a base class and print object is on. */
return value_of_variable (exp->elts[pc + 2].symbol,
exp->elts[pc + 1].block);
*************** evaluate_subexp_standard (expect_type, e
*** 1051,1056 ****
--- 1038,1068 ----
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
if (noside == EVAL_SKIP)
goto nosideret;
+
+ /* JYG: if print object is on we need to replace the base type
+ with rtti type in order to continue on with successful
+ lookup of member / method only available in the rtti type. */
+ {
+ struct type *type = VALUE_TYPE (arg1);
+ struct type *real_type;
+ int full, top, using_enc;
+
+ if (objectprint && TYPE_TARGET_TYPE(type) &&
+ (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
+ {
+ real_type = value_rtti_target_type (arg1, &full, &top, &using_enc);
+ if (real_type)
+ {
+ if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ real_type = lookup_pointer_type (real_type);
+ else
+ real_type = lookup_reference_type (real_type);
+
+ arg1 = value_cast (real_type, arg1);
+ }
+ }
+ }
+
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1),
&exp->elts[pc + 2].string,
Index: c-valprint.c
===================================================================
RCS file: /cvs/src/src/gdb/c-valprint.c,v
retrieving revision 1.2
diff -c -3 -p -b -B -w -r1.2 c-valprint.c
*** c-valprint.c 2000/02/08 04:39:01 1.2
--- c-valprint.c 2000/03/30 04:33:38
*************** c_value_print (val, stream, format, pret
*** 481,486 ****
--- 481,497 ----
}
else if (objectprint && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
{
+
+ if (TYPE_CODE(type) == TYPE_CODE_REF)
+ {
+ /* Copy value, change to pointer, so we don't get an
+ * error about a non-pointer type in value_rtti_target_type
+ */
+ value_ptr temparg;
+ temparg=value_copy(val);
+ VALUE_TYPE (temparg) = lookup_pointer_type(TYPE_TARGET_TYPE(type));
+ val=temparg;
+ }
/* Pointer to class, check real type of object */
fprintf_filtered (stream, "(");
real_type = value_rtti_target_type (val, &full, &top, &using_enc);
*************** c_value_print (val, stream, format, pret
*** 497,502 ****
--- 508,516 ----
/* create a reference type referencing the real type */
type = lookup_reference_type (real_type);
}
+ /* JYG: Need to adjust pointer value. */
+ val->aligner.contents[0] -= top;
+
/* Note: When we look up RTTI entries, we don't get any
information on const or volatile attributes */
}
Index: ChangeLog
===================================================================
RCS file: /cvs/src/src/gdb/ChangeLog,v
retrieving revision 1.207
diff -c -3 -p -b -B -w -r1.207 ChangeLog
*** ChangeLog 2000/03/30 03:03:23 1.207
--- ChangeLog 2000/03/30 04:33:39
***************
*** 1,5 ****
--- 1,32 ----
2000-03-29 Daniel Berlin <dan@cgsoftware.com>
+ * values.c (value_headof): Fix demangling, which was wrong. Also,
+ substantially updated code to handle G++ RTTI properly.
+ * eval.c (evaluate_subexp_standard): for OP_VAR_VALUE, always
+ return full value object; for STRUCTOP_PTR, use pointer to
+ rtti type to get member / method if objectprint is set and
+ target type of pointer is class.
+ * typeprint.c (whatis_exp): if objectprint is set and exp is of
+ pointer / reference type to a class object, look up and print
+ the pointer / reference to rtti type.
+ * valops.c (value_cast): when casting a pointer / reference type
+ of a class object to pointer / refer to its rtti type, adjust
+ the new pointer value accordingly.
+ (value_rtti_type): Handle G++ RTTI properly.
+ * c-valprint.c (c_value_print): adjust pointer value when
+ objectprint is set and pointer type is changed to point to the
+ rtti type.
+
+ * valops.c (find_overload_match): Only check_stub_method those
+ methods that could possibly match our overload, so we stop getting
+ errors that really have nothing to do with the current overload.
+ * gdbtypes.c (rank_one_type): If the names match, the types are
+ the same. Happens during method stub conversion.
+
+ * gdbtypes.c (check_stub_method): Fix template handling. Before we
+ would get confused by them, and come up with a completely wrong
+ argument name.
+
* minsyms.c (add_minsym_to_demangled_hash_table): New function.
(install_minimal_symbols): Fix demangled symbol problems caused by
using add_minsym_to_hash_table for the demangled names, which is
Index: valops.c
===================================================================
RCS file: /cvs/src/src/gdb/valops.c,v
retrieving revision 1.6
diff -c -3 -p -b -B -w -r1.6 valops.c
*** valops.c 2000/03/13 10:01:23 1.6
--- valops.c 2000/03/30 04:33:40
***************
*** 38,44 ****
value operations with HP aCC code/runtime. */
extern int hp_som_som_object_present;
!
/* Local functions. */
static int typecmp PARAMS ((int staticp, struct type * t1[], value_ptr t2[]));
--- 38,44 ----
value operations with HP aCC code/runtime. */
extern int hp_som_som_object_present;
! extern int overload_debug;
/* Local functions. */
static int typecmp PARAMS ((int staticp, struct type * t1[], value_ptr t2[]));
*************** value_cast (type, arg2)
*** 324,329 ****
--- 324,335 ----
value_ptr v2 = value_ind (arg2);
VALUE_ADDRESS (v2) -= VALUE_ADDRESS (v)
+ VALUE_OFFSET (v);
+
+ /* JYG: adjust the new pointer value and
+ embedded offset. */
+ v2->aligner.contents[0] -= VALUE_EMBEDDED_OFFSET (v);
+ VALUE_EMBEDDED_OFFSET (v2) = 0;
+
v2 = value_addr (v2);
VALUE_TYPE (v2) = type;
return v2;
*************** find_overload_match (arg_types, nargs, n
*** 2775,2781 ****
for (j = 0; j < len2; j++)
{
! if (TYPE_FN_FIELD_STUB (f, j))
check_stub_method (domain, i, j);
}
}
--- 2781,2787 ----
for (j = 0; j < len2; j++)
{
! if (TYPE_FN_FIELD_STUB (f, j) && (!strcmp_iw (TYPE_FN_FIELDLIST_NAME (domain,i),name)))
check_stub_method (domain, i, j);
}
}
*************** find_overload_match (arg_types, nargs, n
*** 2863,2881 ****
break;
}
free (parm_types);
! #ifdef DEBUG_OLOAD
! /* FIXME: cagney/2000-03-12: Send the output to gdb_stderr. See
! comments above about adding a ``set debug'' command. */
if (method)
! printf ("Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
else
! printf ("Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
for (jj = 0; jj < nargs; jj++)
! printf ("...Badness @ %d : %d\n", jj, bv->rank[jj]);
! printf ("Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
! #endif
} /* end loop over all candidates */
-
/* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
if they have the exact same goodness. This is because there is no
way to differentiate based on return type, which we need to in
--- 2869,2885 ----
break;
}
free (parm_types);
! if (overload_debug)
! {
if (method)
! fprintf_filtered (gdb_stderr,"Overloaded method instance %s, # of parms %d\n", fns_ptr[ix].physname, nparms);
else
! fprintf_filtered (gdb_stderr,"Overloaded function instance %s # of parms %d\n", SYMBOL_DEMANGLED_NAME (oload_syms[ix]), nparms);
for (jj = 0; jj < nargs; jj++)
! fprintf_filtered (gdb_stderr,"...Badness @ %d : %d\n", jj, bv->rank[jj]);
! fprintf_filtered (gdb_stderr,"Overload resolution champion is %d, ambiguous? %d\n", oload_champ, oload_ambiguous);
! }
} /* end loop over all candidates */
/* NOTE: dan/2000-03-10: Seems to be a better idea to just pick one
if they have the exact same goodness. This is because there is no
way to differentiate based on return type, which we need to in
*************** value_rtti_type (v, full, top, using_enc
*** 3241,3247 ****
/* RTTI works only or class objects */
if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)
return NULL;
!
/* If neither the declared type nor the enclosing type of the
* value structure has a HP ANSI C++ style virtual table,
* we can't do anything. */
--- 3244,3251 ----
/* RTTI works only or class objects */
if (TYPE_CODE (known_type) != TYPE_CODE_CLASS)
return NULL;
! if (TYPE_HAS_VTABLE(known_type))
! {
/* If neither the declared type nor the enclosing type of the
* value structure has a HP ANSI C++ style virtual table,
* we can't do anything. */
*************** value_rtti_type (v, full, top, using_enc
*** 3299,3312 ****
if (!rtti_type)
error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name);
CHECK_TYPEDEF (rtti_type);
!
! #if 0 /* debugging */
printf ("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type), TYPE_TAG_NAME (rtti_type), full ? *full : -1);
#endif
-
/* Check whether we have the entire object */
if (full /* Non-null pointer passed */
-
&&
/* Either we checked on the whole object in hand and found the
top offset to be zero */
--- 3303,3313 ----
if (!rtti_type)
error ("Could not find run-time type: invalid type name %s in typeinfo??", rtti_type_name);
CHECK_TYPEDEF (rtti_type);
! #if 0
printf ("RTTI type name %s, tag %s, full? %d\n", TYPE_NAME (rtti_type), TYPE_TAG_NAME (rtti_type), full ? *full : -1);
#endif
/* Check whether we have the entire object */
if (full /* Non-null pointer passed */
&&
/* Either we checked on the whole object in hand and found the
top offset to be zero */
*************** value_rtti_type (v, full, top, using_enc
*** 3321,3327 ****
--- 3322,3424 ----
TYPE_LENGTH (VALUE_ENCLOSING_TYPE (v)) == TYPE_LENGTH (rtti_type))))
*full = 1;
+ }
+ else
+ /*
+ Right now this is G++ RTTI. Plan on this changing in the
+ future as i get around to setting the vtables properly for G++
+ compiled stuff
+ */
+ {
+ CORE_ADDR vtbl;
+ struct minimal_symbol *minsym;
+ struct symbol *sym;
+ char *demangled_name;
+ struct type *btype;
+ /* If the type has no vptr fieldno, try to get it filled in */
+ if (TYPE_VPTR_FIELDNO(known_type) < 0)
+ fill_in_vptr_fieldno(known_type);
+
+ /* If we still can't find one, give up */
+ if (TYPE_VPTR_FIELDNO(known_type) < 0)
+ return NULL;
+
+ /* Make sure our basetype and known type match, otherwise, cast
+ so we can get at the vtable properly.
+ */
+ btype = TYPE_VPTR_BASETYPE (known_type);
+ CHECK_TYPEDEF (btype);
+ if (btype != known_type )
+ {
+ v = value_cast (btype, v);
+ if (using_enc)
+ *using_enc=1;
+ }
+
+ /*
+ We can't use value_ind here, because it would want to use RTTI.
+ Besides, we don't care about the type, just the actual pointer
+ */
+ if (VALUE_ADDRESS(value_field(v,TYPE_VPTR_FIELDNO(known_type))) == NULL)
+ return NULL;
+
+ /*
+ If we are enclosed by something that isn't us, adjust the
+ address properly and set using_enclosing.
+ */
+ if (VALUE_ENCLOSING_TYPE(v) != VALUE_TYPE(v))
+ {
+ value_ptr tempval;
+ tempval=value_field(v,TYPE_VPTR_FIELDNO(known_type));
+ VALUE_ADDRESS(tempval)+=(TYPE_BASECLASS_BITPOS(known_type,TYPE_VPTR_FIELDNO(known_type))/8);
+ vtbl=value_as_pointer(tempval);
+ using_enclosing=1;
+ }
+ else
+ {
+ vtbl=value_as_pointer(value_field(v,TYPE_VPTR_FIELDNO(known_type)));
+ using_enclosing=0;
+ }
+
+ /* Try to find a symbol that is the vtable */
+ minsym=lookup_minimal_symbol_by_pc(vtbl);
+ if (minsym==NULL || (demangled_name=SYMBOL_NAME(minsym))==NULL || !VTBL_PREFIX_P(demangled_name))
+ return NULL;
+
+ /* If we just skip the prefix, we get screwed by namespaces */
+ demangled_name=cplus_demangle(demangled_name,DMGL_PARAMS|DMGL_ANSI);
+ *(strchr(demangled_name,' '))=0;
+
+ /* Lookup the type for the name */
+ rtti_type=lookup_typename(demangled_name, (struct block *)0,1);
+
+ if (rtti_type==NULL)
+ return NULL;
+
+ if (TYPE_N_BASECLASSES(rtti_type) > 1 && full && (*full) != 1)
+ {
+ if (top)
+ *top=TYPE_BASECLASS_BITPOS(rtti_type,TYPE_VPTR_FIELDNO(rtti_type))/8;
+ if (top && ((*top) >0))
+ if (TYPE_LENGTH(rtti_type) > TYPE_LENGTH(known_type))
+ {
+ if (full)
+ *full=0;
+ }
+ else
+ {
+ if (full)
+ *full=1;
+ }
+ }
+ else
+ {
+ if (full)
+ *full=1;
+ }
+ *using_enc=using_enclosing;
+ }
return rtti_type;
}
Index: values.c
===================================================================
RCS file: /cvs/src/src/gdb/values.c,v
retrieving revision 1.2
diff -c -3 -p -b -B -w -r1.2 values.c
*** values.c 2000/03/21 01:27:34 1.2
--- values.c 2000/03/30 04:33:40
*************** value_headof (in_arg, btype, dtype)
*** 1124,1129 ****
--- 1124,1144 ----
arg = in_arg;
if (btype != dtype)
arg = value_cast (lookup_pointer_type (btype), arg);
+ if (TYPE_CODE (VALUE_TYPE (arg)) == TYPE_CODE_REF)
+ {
+ /*
+ * Copy the value, but change the type from (T&) to (T*).
+ * We keep the same location information, which is efficient,
+ * and allows &(&X) to get the location containing the reference.
+ */
+ arg = value_copy (arg);
+ VALUE_TYPE (arg) = lookup_pointer_type (TYPE_TARGET_TYPE (VALUE_TYPE (arg)));
+ }
+ if (VALUE_ADDRESS(value_field (value_ind(arg), TYPE_VPTR_FIELDNO (btype)))==0)
+ return arg;
+ vtbl = value_field(value_ind (arg),TYPE_VPTR_FIELDNO (btype));
+ VALUE_ADDRESS(vtbl)+=4;
+
vtbl = value_ind (value_field (value_ind (arg), TYPE_VPTR_FIELDNO (btype)));
/* Check that VTBL looks like it points to a virtual function table. */
*************** value_headof (in_arg, btype, dtype)
*** 1141,1150 ****
VALUE_TYPE (in_arg) = error_type;
return in_arg;
}
-
/* Now search through the virtual function table. */
! entry = value_ind (vtbl);
! nelems = longest_to_int (value_as_long (value_field (entry, 2)));
for (i = 1; i <= nelems; i++)
{
entry = value_subscript (vtbl, value_from_longest (builtin_type_int,
--- 1156,1168 ----
VALUE_TYPE (in_arg) = error_type;
return in_arg;
}
/* Now search through the virtual function table. */
! /* djb 03-29-2000 I fixed this so if it could work, it would. Never
! seen it needed, however. Consider it on notice that i consider it
! useless, and unless told otherwise, will delete it for 5.1
! */
! entry = value_ind(value_addr(vtbl));
! nelems = longest_to_int (value_as_long (value_field (entry, 1)));
for (i = 1; i <= nelems; i++)
{
entry = value_subscript (vtbl, value_from_longest (builtin_type_int,
*************** value_headof (in_arg, btype, dtype)
*** 1169,1175 ****
* But we leave it in for future use, when we will hopefully
* have optimizes the vtable to use thunks instead of offsets. */
/* Use the name of vtable itself to extract a base type. */
! demangled_name += 4; /* Skip _vt$ prefix. */
}
else
{
--- 1187,1198 ----
* But we leave it in for future use, when we will hopefully
* have optimizes the vtable to use thunks instead of offsets. */
/* Use the name of vtable itself to extract a base type. */
!
! /* if we just skip the prefix, we'll get raped by namespaces.
! * So demangle it and find the first space
! */
! demangled_name = cplus_demangle(demangled_name,DMGL_ANSI);
! *(strchr (demangled_name, ' ')) = '\0';
}
else
{
Index: gdbtypes.c
===================================================================
RCS file: /cvs/src/src/gdb/gdbtypes.c,v
retrieving revision 1.6
diff -c -3 -p -b -B -w -r1.6 gdbtypes.c
*** gdbtypes.c 2000/03/28 02:25:14 1.6
--- gdbtypes.c 2000/03/30 04:33:40
*************** check_stub_method (type, method_id, sign
*** 1459,1469 ****
argtypetext = p;
while (*p)
{
! if (*p == '(')
{
depth += 1;
}
! else if (*p == ')')
{
depth -= 1;
}
--- 1459,1469 ----
argtypetext = p;
while (*p)
{
! if (*p == '(' || *p == '<')
{
depth += 1;
}
! else if (*p == ')' || *p == '>')
{
depth -= 1;
}
*************** check_stub_method (type, method_id, sign
*** 1502,1512 ****
argtypetext = p + 1;
}
! if (*p == '(')
{
depth += 1;
}
! else if (*p == ')')
{
depth -= 1;
}
--- 1502,1512 ----
argtypetext = p + 1;
}
! if (*p == '(' || *p == '<')
{
depth += 1;
}
! else if (*p == ')' || *p == '>')
{
depth -= 1;
}
*************** rank_one_type (parm, arg)
*** 2173,2178 ****
--- 2173,2188 ----
parm = check_typedef (parm);
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)