if (! debug_type_samep (info, *a1, *a2)) break;
{ if (! debug_type_samep (info, *a1, *a2)) break; ++a1; ++a2; }
debug_type_samep (info, t1, t2)     struct debug_handle *info;     struct debug_type *t1;     struct debug_type *t2;{  struct debug_type_compare_list *l;  struct debug_type_compare_list top;  boolean ret;  while (t1->kind == DEBUG_KIND_INDIRECT)    {      t1 = *t1->u.kindirect->slot;      if (t1 == NULL)	return false;    }  while (t2->kind == DEBUG_KIND_INDIRECT)    {      t2 = *t2->u.kindirect->slot;      if (t2 == NULL)	return false;    }  if (t1 == t2)    return true;  /* As a special case, permit a typedef to match a tag, since C++     debugging output will sometimes add a typedef where C debugging     output will not.  */  if (t1->kind == DEBUG_KIND_NAMED      && t2->kind == DEBUG_KIND_TAGGED)    return debug_type_samep (info, t1->u.knamed->type, t2);  else if (t1->kind == DEBUG_KIND_TAGGED	   && t2->kind == DEBUG_KIND_NAMED)    return debug_type_samep (info, t1, t2->u.knamed->type);  if (t1->kind != t2->kind      || t1->size != t2->size)    return false;  /* Get rid of the trivial cases first.  */  switch (t1->kind)    {    default:      break;    case DEBUG_KIND_VOID:    case DEBUG_KIND_FLOAT:    case DEBUG_KIND_COMPLEX:    case DEBUG_KIND_BOOL:      return true;    case DEBUG_KIND_INT:      return t1->u.kint == t2->u.kint;    }  /* We have to avoid an infinite recursion.  We do this by keeping a     list of types which we are comparing.  We just keep the list on     the stack.  If we encounter a pair of types we are currently     comparing, we just assume that they are equal.  */  for (l = info->compare_list; l != NULL; l = l->next)    {      if (l->t1 == t1 && l->t2 == t2)	return true;    }  top.t1 = t1;  top.t2 = t2;  top.next = info->compare_list;  info->compare_list = &top;  switch (t1->kind)    {    default:      abort ();      ret = false;      break;    case DEBUG_KIND_STRUCT:    case DEBUG_KIND_UNION:    case DEBUG_KIND_CLASS:    case DEBUG_KIND_UNION_CLASS:      if (t1->u.kclass == NULL)	ret = t2->u.kclass == NULL;      else if (t2->u.kclass == NULL)	ret = false;      else if (t1->u.kclass->id > info->base_id	       && t1->u.kclass->id == t2->u.kclass->id)	ret = true;      else	ret = debug_class_type_samep (info, t1, t2);      break;    case DEBUG_KIND_ENUM:      if (t1->u.kenum == NULL)	ret = t2->u.kenum == NULL;      else if (t2->u.kenum == NULL)	ret = false;      else	{	  const char **pn1, **pn2;	  bfd_signed_vma *pv1, *pv2;	  pn1 = t1->u.kenum->names;	  pn2 = t2->u.kenum->names;	  pv1 = t1->u.kenum->values;	  pv2 = t2->u.kenum->values;	  while (*pn1 != NULL && *pn2 != NULL)	    {	      if (**pn1 != **pn2		  || *pv1 != *pv2		  || strcmp (*pn1, *pn2) != 0)		break;	      ++pn1;	      ++pn2;	      ++pv1;	      ++pv2;	    }	  ret = *pn1 == NULL && *pn2 == NULL;	}      break;    case DEBUG_KIND_POINTER:      ret = debug_type_samep (info, t1->u.kpointer, t2->u.kpointer);      break;	         case DEBUG_KIND_FUNCTION:      if (t1->u.kfunction->varargs != t2->u.kfunction->varargs	  || ! debug_type_samep (info, t1->u.kfunction->return_type,				 t2->u.kfunction->return_type)	  || ((t1->u.kfunction->arg_types == NULL)	      != (t2->u.kfunction->arg_types == NULL)))	ret = false;      else if (t1->u.kfunction->arg_types == NULL)	ret = true;      else	{	  struct debug_type **a1, **a2;	  a1 = t1->u.kfunction->arg_types;	  a2 = t2->u.kfunction->arg_types;	  while (*a1 != NULL && *a2 != NULL)	    if (! debug_type_samep (info, *a1, *a2))	      break;	  ret = *a1 == NULL && *a2 == NULL;	}      break;    case DEBUG_KIND_REFERENCE:      ret = debug_type_samep (info, t1->u.kreference, t2->u.kreference);      break;    case DEBUG_KIND_RANGE:      ret = (t1->u.krange->lower == t2->u.krange->lower	     && t1->u.krange->upper == t2->u.krange->upper	     && debug_type_samep (info, t1->u.krange->type,				  t2->u.krange->type));    case DEBUG_KIND_ARRAY:      ret = (t1->u.karray->lower == t2->u.karray->lower	     && t1->u.karray->upper == t2->u.karray->upper	     && t1->u.karray->stringp == t2->u.karray->stringp	     && debug_type_samep (info, t1->u.karray->element_type,				  t2->u.karray->element_type));      break;    case DEBUG_KIND_SET:      ret = (t1->u.kset->bitstringp == t2->u.kset->bitstringp	     && debug_type_samep (info, t1->u.kset->type, t2->u.kset->type));      break;    case DEBUG_KIND_OFFSET:      ret = (debug_type_samep (info, t1->u.koffset->base_type,			       t2->u.koffset->base_type)	     && debug_type_samep (info, t1->u.koffset->target_type,				  t2->u.koffset->target_type));      break;    case DEBUG_KIND_METHOD:      if (t1->u.kmethod->varargs != t2->u.kmethod->varargs	  || ! debug_type_samep (info, t1->u.kmethod->return_type,				 t2->u.kmethod->return_type)	  || ! debug_type_samep (info, t1->u.kmethod->domain_type,				 t2->u.kmethod->domain_type)	  || ((t1->u.kmethod->arg_types == NULL)	      != (t2->u.kmethod->arg_types == NULL)))	ret = false;      else if (t1->u.kmethod->arg_types == NULL)	ret = true;      else	{	  struct debug_type **a1, **a2;	  a1 = t1->u.kmethod->arg_types;	  a2 = t2->u.kmethod->arg_types;	  while (*a1 != NULL && *a2 != NULL)	    if (! debug_type_samep (info, *a1, *a2))	      break;	  ret = *a1 == NULL && *a2 == NULL;	}      break;    case DEBUG_KIND_CONST:      ret = debug_type_samep (info, t1->u.kconst, t2->u.kconst);      break;    case DEBUG_KIND_VOLATILE:      ret = debug_type_samep (info, t1->u.kvolatile, t2->u.kvolatile);      break;    case DEBUG_KIND_NAMED:    case DEBUG_KIND_TAGGED:      ret = (strcmp (t1->u.knamed->name->name, t2->u.knamed->name->name) == 0	     && debug_type_samep (info, t1->u.knamed->type,				  t2->u.knamed->type));      break;    }  info->compare_list = top.next;  return ret;}