contrib/binutils-2.22/binutils/debug.c

   1 /* debug.c -- Handle generic debugging information.
   2    Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2005, 2007,
   3    2009  Free Software Foundation, Inc.
   4    Written by Ian Lance Taylor <ian@cygnus.com>.
   5
   6    This file is part of GNU Binutils.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
  21    02110-1301, USA.  */
  22
  23
  24 /* This file implements a generic debugging format.  We may eventually
  25    have readers which convert different formats into this generic
  26    format, and writers which write it out.  The initial impetus for
  27    this was writing a converter from stabs to HP IEEE-695 debugging
  28    format.  */
  29
  30 #include "sysdep.h"
  31 #include <assert.h>
  32 #include "bfd.h"
  33 #include "libiberty.h"
  34 #include "filenames.h"
  35 #include "debug.h"
  36
  37 /* Global information we keep for debugging.  A pointer to this
  38    structure is the debugging handle passed to all the routines.  */
  39
  40 struct debug_handle
  41 {
  42   /* A linked list of compilation units.  */
  43   struct debug_unit *units;
  44   /* The current compilation unit.  */
  45   struct debug_unit *current_unit;
  46   /* The current source file.  */
  47   struct debug_file *current_file;
  48   /* The current function.  */
  49   struct debug_function *current_function;
  50   /* The current block.  */
  51   struct debug_block *current_block;
  52   /* The current line number information for the current unit.  */
  53   struct debug_lineno *current_lineno;
  54   /* Mark.  This is used by debug_write.  */
  55   unsigned int mark;
  56   /* A struct/class ID used by debug_write.  */
  57   unsigned int class_id;
  58   /* The base for class_id for this call to debug_write.  */
  59   unsigned int base_id;
  60   /* The current line number in debug_write.  */
  61   struct debug_lineno *current_write_lineno;
  62   unsigned int current_write_lineno_index;
  63   /* A list of classes which have assigned ID's during debug_write.
  64      This is linked through the next_id field of debug_class_type.  */
  65   struct debug_class_id *id_list;
  66   /* A list used to avoid recursion during debug_type_samep.  */
  67   struct debug_type_compare_list *compare_list;
  68 };
  69
  70 /* Information we keep for a single compilation unit.  */
  71
  72 struct debug_unit
  73 {
  74   /* The next compilation unit.  */
  75   struct debug_unit *next;
  76   /* A list of files included in this compilation unit.  The first
  77      file is always the main one, and that is where the main file name
  78      is stored.  */
  79   struct debug_file *files;
  80   /* Line number information for this compilation unit.  This is not
  81      stored by function, because assembler code may have line number
  82      information without function information.  */
  83   struct debug_lineno *linenos;
  84 };
  85
  86 /* Information kept for a single source file.  */
  87
  88 struct debug_file
  89 {
  90   /* The next source file in this compilation unit.  */
  91   struct debug_file *next;
  92   /* The name of the source file.  */
  93   const char *filename;
  94   /* Global functions, variables, types, etc.  */
  95   struct debug_namespace *globals;
  96 };
  97
  98 /* A type.  */
  99
 100 struct debug_type_s
 101 {
 102   /* Kind of type.  */
 103   enum debug_type_kind kind;
 104   /* Size of type (0 if not known).  */
 105   unsigned int size;
 106   /* Type which is a pointer to this type.  */
 107   debug_type pointer;
 108   /* Tagged union with additional information about the type.  */
 109   union
 110     {
 111       /* DEBUG_KIND_INDIRECT.  */
 112       struct debug_indirect_type *kindirect;
 113       /* DEBUG_KIND_INT.  */
 114       /* Whether the integer is unsigned.  */
 115       bfd_boolean kint;
 116       /* DEBUG_KIND_STRUCT, DEBUG_KIND_UNION, DEBUG_KIND_CLASS,
 117          DEBUG_KIND_UNION_CLASS.  */
 118       struct debug_class_type *kclass;
 119       /* DEBUG_KIND_ENUM.  */
 120       struct debug_enum_type *kenum;
 121       /* DEBUG_KIND_POINTER.  */
 122       struct debug_type_s *kpointer;
 123       /* DEBUG_KIND_FUNCTION.  */
 124       struct debug_function_type *kfunction;
 125       /* DEBUG_KIND_REFERENCE.  */
 126       struct debug_type_s *kreference;
 127       /* DEBUG_KIND_RANGE.  */
 128       struct debug_range_type *krange;
 129       /* DEBUG_KIND_ARRAY.  */
 130       struct debug_array_type *karray;
 131       /* DEBUG_KIND_SET.  */
 132       struct debug_set_type *kset;
 133       /* DEBUG_KIND_OFFSET.  */
 134       struct debug_offset_type *koffset;
 135       /* DEBUG_KIND_METHOD.  */
 136       struct debug_method_type *kmethod;
 137       /* DEBUG_KIND_CONST.  */
 138       struct debug_type_s *kconst;
 139       /* DEBUG_KIND_VOLATILE.  */
 140       struct debug_type_s *kvolatile;
 141       /* DEBUG_KIND_NAMED, DEBUG_KIND_TAGGED.  */
 142       struct debug_named_type *knamed;
 143     } u;
 144 };
 145
 146 /* Information kept for an indirect type.  */
 147
 148 struct debug_indirect_type
 149 {
 150   /* Slot where the final type will appear.  */
 151   debug_type *slot;
 152   /* Tag.  */
 153   const char *tag;
 154 };
 155
 156 /* Information kept for a struct, union, or class.  */
 157
 158 struct debug_class_type
 159 {
 160   /* NULL terminated array of fields.  */
 161   debug_field *fields;
 162   /* A mark field which indicates whether the struct has already been
 163      printed.  */
 164   unsigned int mark;
 165   /* This is used to uniquely identify unnamed structs when printing.  */
 166   unsigned int id;
 167   /* The remaining fields are only used for DEBUG_KIND_CLASS and
 168      DEBUG_KIND_UNION_CLASS.  */
 169   /* NULL terminated array of base classes.  */
 170   debug_baseclass *baseclasses;
 171   /* NULL terminated array of methods.  */
 172   debug_method *methods;
 173   /* The type of the class providing the virtual function table for
 174      this class.  This may point to the type itself.  */
 175   debug_type vptrbase;
 176 };
 177
 178 /* Information kept for an enum.  */
 179
 180 struct debug_enum_type
 181 {
 182   /* NULL terminated array of names.  */
 183   const char **names;
 184   /* Array of corresponding values.  */
 185   bfd_signed_vma *values;
 186 };
 187
 188 /* Information kept for a function.  FIXME: We should be able to
 189    record the parameter types.  */
 190
 191 struct debug_function_type
 192 {
 193   /* Return type.  */
 194   debug_type return_type;
 195   /* NULL terminated array of argument types.  */
 196   debug_type *arg_types;
 197   /* Whether the function takes a variable number of arguments.  */
 198   bfd_boolean varargs;
 199 };
 200
 201 /* Information kept for a range.  */
 202
 203 struct debug_range_type
 204 {
 205   /* Range base type.  */
 206   debug_type type;
 207   /* Lower bound.  */
 208   bfd_signed_vma lower;
 209   /* Upper bound.  */
 210   bfd_signed_vma upper;
 211 };
 212
 213 /* Information kept for an array.  */
 214
 215 struct debug_array_type
 216 {
 217   /* Element type.  */
 218   debug_type element_type;
 219   /* Range type.  */
 220   debug_type range_type;
 221   /* Lower bound.  */
 222   bfd_signed_vma lower;
 223   /* Upper bound.  */
 224   bfd_signed_vma upper;
 225   /* Whether this array is really a string.  */
 226   bfd_boolean stringp;
 227 };
 228
 229 /* Information kept for a set.  */
 230
 231 struct debug_set_type
 232 {
 233   /* Base type.  */
 234   debug_type type;
 235   /* Whether this set is really a bitstring.  */
 236   bfd_boolean bitstringp;
 237 };
 238
 239 /* Information kept for an offset type (a based pointer).  */
 240
 241 struct debug_offset_type
 242 {
 243   /* The type the pointer is an offset from.  */
 244   debug_type base_type;
 245   /* The type the pointer points to.  */
 246   debug_type target_type;
 247 };
 248
 249 /* Information kept for a method type.  */
 250
 251 struct debug_method_type
 252 {
 253   /* The return type.  */
 254   debug_type return_type;
 255   /* The object type which this method is for.  */
 256   debug_type domain_type;
 257   /* A NULL terminated array of argument types.  */
 258   debug_type *arg_types;
 259   /* Whether the method takes a variable number of arguments.  */
 260   bfd_boolean varargs;
 261 };
 262
 263 /* Information kept for a named type.  */
 264
 265 struct debug_named_type
 266 {
 267   /* Name.  */
 268   struct debug_name *name;
 269   /* Real type.  */
 270   debug_type type;
 271 };
 272
 273 /* A field in a struct or union.  */
 274
 275 struct debug_field_s
 276 {
 277   /* Name of the field.  */
 278   const char *name;
 279   /* Type of the field.  */
 280   struct debug_type_s *type;
 281   /* Visibility of the field.  */
 282   enum debug_visibility visibility;
 283   /* Whether this is a static member.  */
 284   bfd_boolean static_member;
 285   union
 286     {
 287       /* If static_member is false.  */
 288       struct
 289         {
 290           /* Bit position of the field in the struct.  */
 291           unsigned int bitpos;
 292           /* Size of the field in bits.  */
 293           unsigned int bitsize;
 294         } f;
 295       /* If static_member is true.  */
 296       struct
 297         {
 298           const char *physname;
 299         } s;
 300     } u;
 301 };
 302
 303 /* A base class for an object.  */
 304
 305 struct debug_baseclass_s
 306 {
 307   /* Type of the base class.  */
 308   struct debug_type_s *type;
 309   /* Bit position of the base class in the object.  */
 310   unsigned int bitpos;
 311   /* Whether the base class is virtual.  */
 312   bfd_boolean is_virtual;
 313   /* Visibility of the base class.  */
 314   enum debug_visibility visibility;
 315 };
 316
 317 /* A method of an object.  */
 318
 319 struct debug_method_s
 320 {
 321   /* The name of the method.  */
 322   const char *name;
 323   /* A NULL terminated array of different types of variants.  */
 324   struct debug_method_variant_s **variants;
 325 };
 326
 327 /* The variants of a method function of an object.  These indicate
 328    which method to run.  */
 329
 330 struct debug_method_variant_s
 331 {
 332   /* The physical name of the function.  */
 333   const char *physname;
 334   /* The type of the function.  */
 335   struct debug_type_s *type;
 336   /* The visibility of the function.  */
 337   enum debug_visibility visibility;
 338   /* Whether the function is const.  */
 339   bfd_boolean constp;
 340   /* Whether the function is volatile.  */
 341   bfd_boolean volatilep;
 342   /* The offset to the function in the virtual function table.  */
 343   bfd_vma voffset;
 344   /* If voffset is VOFFSET_STATIC_METHOD, this is a static method.  */
 345 #define VOFFSET_STATIC_METHOD ((bfd_vma) -1)
 346   /* Context of a virtual method function.  */
 347   struct debug_type_s *context;
 348 };
 349
 350 /* A variable.  This is the information we keep for a variable object.
 351    This has no name; a name is associated with a variable in a
 352    debug_name structure.  */
 353
 354 struct debug_variable
 355 {
 356   /* Kind of variable.  */
 357   enum debug_var_kind kind;
 358   /* Type.  */
 359   debug_type type;
 360   /* Value.  The interpretation of the value depends upon kind.  */
 361   bfd_vma val;
 362 };
 363
 364 /* A function.  This has no name; a name is associated with a function
 365    in a debug_name structure.  */
 366
 367 struct debug_function
 368 {
 369   /* Return type.  */
 370   debug_type return_type;
 371   /* Parameter information.  */
 372   struct debug_parameter *parameters;
 373   /* Block information.  The first structure on the list is the main
 374      block of the function, and describes function local variables.  */
 375   struct debug_block *blocks;
 376 };
 377
 378 /* A function parameter.  */
 379
 380 struct debug_parameter
 381 {
 382   /* Next parameter.  */
 383   struct debug_parameter *next;
 384   /* Name.  */
 385   const char *name;
 386   /* Type.  */
 387   debug_type type;
 388   /* Kind.  */
 389   enum debug_parm_kind kind;
 390   /* Value (meaning depends upon kind).  */
 391   bfd_vma val;
 392 };
 393
 394 /* A typed constant.  */
 395
 396 struct debug_typed_constant
 397 {
 398   /* Type.  */
 399   debug_type type;
 400   /* Value.  FIXME: We may eventually need to support non-integral
 401      values.  */
 402   bfd_vma val;
 403 };
 404
 405 /* Information about a block within a function.  */
 406
 407 struct debug_block
 408 {
 409   /* Next block with the same parent.  */
 410   struct debug_block *next;
 411   /* Parent block.  */
 412   struct debug_block *parent;
 413   /* List of child blocks.  */
 414   struct debug_block *children;
 415   /* Start address of the block.  */
 416   bfd_vma start;
 417   /* End address of the block.  */
 418   bfd_vma end;
 419   /* Local variables.  */
 420   struct debug_namespace *locals;
 421 };
 422
 423 /* Line number information we keep for a compilation unit.  FIXME:
 424    This structure is easy to create, but can be very space
 425    inefficient.  */
 426
 427 struct debug_lineno
 428 {
 429   /* More line number information for this block.  */
 430   struct debug_lineno *next;
 431   /* Source file.  */
 432   struct debug_file *file;
 433   /* Line numbers, terminated by a -1 or the end of the array.  */
 434 #define DEBUG_LINENO_COUNT 10
 435   unsigned long linenos[DEBUG_LINENO_COUNT];
 436   /* Addresses for the line numbers.  */
 437   bfd_vma addrs[DEBUG_LINENO_COUNT];
 438 };
 439
 440 /* A namespace.  This is a mapping from names to objects.  FIXME: This
 441    should be implemented as a hash table.  */
 442
 443 struct debug_namespace
 444 {
 445   /* List of items in this namespace.  */
 446   struct debug_name *list;
 447   /* Pointer to where the next item in this namespace should go.  */
 448   struct debug_name **tail;
 449 };
 450
 451 /* Kinds of objects that appear in a namespace.  */
 452
 453 enum debug_object_kind
 454 {
 455   /* A type.  */
 456   DEBUG_OBJECT_TYPE,
 457   /* A tagged type (really a different sort of namespace).  */
 458   DEBUG_OBJECT_TAG,
 459   /* A variable.  */
 460   DEBUG_OBJECT_VARIABLE,
 461   /* A function.  */
 462   DEBUG_OBJECT_FUNCTION,
 463   /* An integer constant.  */
 464   DEBUG_OBJECT_INT_CONSTANT,
 465   /* A floating point constant.  */
 466   DEBUG_OBJECT_FLOAT_CONSTANT,
 467   /* A typed constant.  */
 468   DEBUG_OBJECT_TYPED_CONSTANT
 469 };
 470
 471 /* Linkage of an object that appears in a namespace.  */
 472
 473 enum debug_object_linkage
 474 {
 475   /* Local variable.  */
 476   DEBUG_LINKAGE_AUTOMATIC,
 477   /* Static--either file static or function static, depending upon the
 478      namespace is.  */
 479   DEBUG_LINKAGE_STATIC,
 480   /* Global.  */
 481   DEBUG_LINKAGE_GLOBAL,
 482   /* No linkage.  */
 483   DEBUG_LINKAGE_NONE
 484 };
 485
 486 /* A name in a namespace.  */
 487
 488 struct debug_name
 489 {
 490   /* Next name in this namespace.  */
 491   struct debug_name *next;
 492   /* Name.  */
 493   const char *name;
 494   /* Mark.  This is used by debug_write.  */
 495   unsigned int mark;
 496   /* Kind of object.  */
 497   enum debug_object_kind kind;
 498   /* Linkage of object.  */
 499   enum debug_object_linkage linkage;
 500   /* Tagged union with additional information about the object.  */
 501   union
 502     {
 503       /* DEBUG_OBJECT_TYPE.  */
 504       struct debug_type_s *type;
 505       /* DEBUG_OBJECT_TAG.  */
 506       struct debug_type_s *tag;
 507       /* DEBUG_OBJECT_VARIABLE.  */
 508       struct debug_variable *variable;
 509       /* DEBUG_OBJECT_FUNCTION.  */
 510       struct debug_function *function;
 511       /* DEBUG_OBJECT_INT_CONSTANT.  */
 512       bfd_vma int_constant;
 513       /* DEBUG_OBJECT_FLOAT_CONSTANT.  */
 514       double float_constant;
 515       /* DEBUG_OBJECT_TYPED_CONSTANT.  */
 516       struct debug_typed_constant *typed_constant;
 517     } u;
 518 };
 519
 520 /* During debug_write, a linked list of these structures is used to
 521    keep track of ID numbers that have been assigned to classes.  */
 522
 523 struct debug_class_id
 524 {
 525   /* Next ID number.  */
 526   struct debug_class_id *next;
 527   /* The type with the ID.  */
 528   struct debug_type_s *type;
 529   /* The tag; NULL if no tag.  */
 530   const char *tag;
 531 };
 532
 533 /* During debug_type_samep, a linked list of these structures is kept
 534    on the stack to avoid infinite recursion.  */
 535
 536 struct debug_type_compare_list
 537 {
 538   /* Next type on list.  */
 539   struct debug_type_compare_list *next;
 540   /* The types we are comparing.  */
 541   struct debug_type_s *t1;
 542   struct debug_type_s *t2;
 543 };
 544
 545 /* During debug_get_real_type, a linked list of these structures is
 546    kept on the stack to avoid infinite recursion.  */
 547
 548 struct debug_type_real_list
 549 {
 550   /* Next type on list.  */
 551   struct debug_type_real_list *next;
 552   /* The type we are checking.  */
 553   struct debug_type_s *t;
 554 };
 555
 556 /* Local functions.  */
 557
 558 static void debug_error (const char *);
 559 static struct debug_name *debug_add_to_namespace
 560   (struct debug_handle *, struct debug_namespace **, const char *,
 561    enum debug_object_kind, enum debug_object_linkage);
 562 static struct debug_name *debug_add_to_current_namespace
 563   (struct debug_handle *, const char *, enum debug_object_kind,
 564    enum debug_object_linkage);
 565 static struct debug_type_s *debug_make_type
 566   (struct debug_handle *, enum debug_type_kind, unsigned int);
 567 static struct debug_type_s *debug_get_real_type
 568   (void *, debug_type, struct debug_type_real_list *);
 569 static bfd_boolean debug_write_name
 570   (struct debug_handle *, const struct debug_write_fns *, void *,
 571    struct debug_name *);
 572 static bfd_boolean debug_write_type
 573   (struct debug_handle *, const struct debug_write_fns *, void *,
 574    struct debug_type_s *, struct debug_name *);
 575 static bfd_boolean debug_write_class_type
 576   (struct debug_handle *, const struct debug_write_fns *, void *,
 577    struct debug_type_s *, const char *);
 578 static bfd_boolean debug_write_function
 579   (struct debug_handle *, const struct debug_write_fns *, void *,
 580    const char *, enum debug_object_linkage, struct debug_function *);
 581 static bfd_boolean debug_write_block
 582   (struct debug_handle *, const struct debug_write_fns *, void *,
 583    struct debug_block *);
 584 static bfd_boolean debug_write_linenos
 585   (struct debug_handle *, const struct debug_write_fns *, void *, bfd_vma);
 586 static bfd_boolean debug_set_class_id
 587   (struct debug_handle *, const char *, struct debug_type_s *);
 588 static bfd_boolean debug_type_samep
 589   (struct debug_handle *, struct debug_type_s *, struct debug_type_s *);
 590 static bfd_boolean debug_class_type_samep
 591   (struct debug_handle *, struct debug_type_s *, struct debug_type_s *);
 592 \f
 593 /* Issue an error message.  */
 594
 595 static void
 596 debug_error (const char *message)
 597 {
 598   fprintf (stderr, "%s\n", message);
 599 }
 600
 601 /* Add an object to a namespace.  */
 602
 603 static struct debug_name *
 604 debug_add_to_namespace (struct debug_handle *info ATTRIBUTE_UNUSED,
 605                         struct debug_namespace **nsp, const char *name,
 606                         enum debug_object_kind kind,
 607                         enum debug_object_linkage linkage)
 608 {
 609   struct debug_name *n;
 610   struct debug_namespace *ns;
 611
 612   n = (struct debug_name *) xmalloc (sizeof *n);
 613   memset (n, 0, sizeof *n);
 614
 615   n->name = name;
 616   n->kind = kind;
 617   n->linkage = linkage;
 618
 619   ns = *nsp;
 620   if (ns == NULL)
 621     {
 622       ns = (struct debug_namespace *) xmalloc (sizeof *ns);
 623       memset (ns, 0, sizeof *ns);
 624
 625       ns->tail = &ns->list;
 626
 627       *nsp = ns;
 628     }
 629
 630   *ns->tail = n;
 631   ns->tail = &n->next;
 632
 633   return n;
 634 }
 635
 636 /* Add an object to the current namespace.  */
 637
 638 static struct debug_name *
 639 debug_add_to_current_namespace (struct debug_handle *info, const char *name,
 640                                 enum debug_object_kind kind,
 641                                 enum debug_object_linkage linkage)
 642 {
 643   struct debug_namespace **nsp;
 644
 645   if (info->current_unit == NULL
 646       || info->current_file == NULL)
 647     {
 648       debug_error (_("debug_add_to_current_namespace: no current file"));
 649       return NULL;
 650     }
 651
 652   if (info->current_block != NULL)
 653     nsp = &info->current_block->locals;
 654   else
 655     nsp = &info->current_file->globals;
 656
 657   return debug_add_to_namespace (info, nsp, name, kind, linkage);
 658 }
 659 \f
 660 /* Return a handle for debugging information.  */
 661
 662 void *
 663 debug_init (void)
 664 {
 665   struct debug_handle *ret;
 666
 667   ret = (struct debug_handle *) xmalloc (sizeof *ret);
 668   memset (ret, 0, sizeof *ret);
 669   return (void *) ret;
 670 }
 671
 672 /* Set the source filename.  This implicitly starts a new compilation
 673    unit.  */
 674
 675 bfd_boolean
 676 debug_set_filename (void *handle, const char *name)
 677 {
 678   struct debug_handle *info = (struct debug_handle *) handle;
 679   struct debug_file *nfile;
 680   struct debug_unit *nunit;
 681
 682   if (name == NULL)
 683     name = "";
 684
 685   nfile = (struct debug_file *) xmalloc (sizeof *nfile);
 686   memset (nfile, 0, sizeof *nfile);
 687
 688   nfile->filename = name;
 689
 690   nunit = (struct debug_unit *) xmalloc (sizeof *nunit);
 691   memset (nunit, 0, sizeof *nunit);
 692
 693   nunit->files = nfile;
 694   info->current_file = nfile;
 695
 696   if (info->current_unit != NULL)
 697     info->current_unit->next = nunit;
 698   else
 699     {
 700       assert (info->units == NULL);
 701       info->units = nunit;
 702     }
 703
 704   info->current_unit = nunit;
 705
 706   info->current_function = NULL;
 707   info->current_block = NULL;
 708   info->current_lineno = NULL;
 709
 710   return TRUE;
 711 }
 712
 713 /* Change source files to the given file name.  This is used for
 714    include files in a single compilation unit.  */
 715
 716 bfd_boolean
 717 debug_start_source (void *handle, const char *name)
 718 {
 719   struct debug_handle *info = (struct debug_handle *) handle;
 720   struct debug_file *f, **pf;
 721
 722   if (name == NULL)
 723     name = "";
 724
 725   if (info->current_unit == NULL)
 726     {
 727       debug_error (_("debug_start_source: no debug_set_filename call"));
 728       return FALSE;
 729     }
 730
 731   for (f = info->current_unit->files; f != NULL; f = f->next)
 732     {
 733       if (filename_cmp (f->filename, name) == 0)
 734         {
 735           info->current_file = f;
 736           return TRUE;
 737         }
 738     }
 739
 740   f = (struct debug_file *) xmalloc (sizeof *f);
 741   memset (f, 0, sizeof *f);
 742
 743   f->filename = name;
 744
 745   for (pf = &info->current_file->next;
 746        *pf != NULL;
 747        pf = &(*pf)->next)
 748     ;
 749   *pf = f;
 750
 751   info->current_file = f;
 752
 753   return TRUE;
 754 }
 755
 756 /* Record a function definition.  This implicitly starts a function
 757    block.  The debug_type argument is the type of the return value.
 758    The boolean indicates whether the function is globally visible.
 759    The bfd_vma is the address of the start of the function.  Currently
 760    the parameter types are specified by calls to
 761    debug_record_parameter.  FIXME: There is no way to specify nested
 762    functions.  */
 763
 764 bfd_boolean
 765 debug_record_function (void *handle, const char *name,
 766                        debug_type return_type, bfd_boolean global,
 767                        bfd_vma addr)
 768 {
 769   struct debug_handle *info = (struct debug_handle *) handle;
 770   struct debug_function *f;
 771   struct debug_block *b;
 772   struct debug_name *n;
 773
 774   if (name == NULL)
 775     name = "";
 776   if (return_type == NULL)
 777     return FALSE;
 778
 779   if (info->current_unit == NULL)
 780     {
 781       debug_error (_("debug_record_function: no debug_set_filename call"));
 782       return FALSE;
 783     }
 784
 785   f = (struct debug_function *) xmalloc (sizeof *f);
 786   memset (f, 0, sizeof *f);
 787
 788   f->return_type = return_type;
 789
 790   b = (struct debug_block *) xmalloc (sizeof *b);
 791   memset (b, 0, sizeof *b);
 792
 793   b->start = addr;
 794   b->end = (bfd_vma) -1;
 795
 796   f->blocks = b;
 797
 798   info->current_function = f;
 799   info->current_block = b;
 800
 801   /* FIXME: If we could handle nested functions, this would be the
 802      place: we would want to use a different namespace.  */
 803   n = debug_add_to_namespace (info,
 804                               &info->current_file->globals,
 805                               name,
 806                               DEBUG_OBJECT_FUNCTION,
 807                               (global
 808                                ? DEBUG_LINKAGE_GLOBAL
 809                                : DEBUG_LINKAGE_STATIC));
 810   if (n == NULL)
 811     return FALSE;
 812
 813   n->u.function = f;
 814
 815   return TRUE;
 816 }
 817
 818 /* Record a parameter for the current function.  */
 819
 820 bfd_boolean
 821 debug_record_parameter (void *handle, const char *name, debug_type type,
 822                         enum debug_parm_kind kind, bfd_vma val)
 823 {
 824   struct debug_handle *info = (struct debug_handle *) handle;
 825   struct debug_parameter *p, **pp;
 826
 827   if (name == NULL || type == NULL)
 828     return FALSE;
 829
 830   if (info->current_unit == NULL
 831       || info->current_function == NULL)
 832     {
 833       debug_error (_("debug_record_parameter: no current function"));
 834       return FALSE;
 835     }
 836
 837   p = (struct debug_parameter *) xmalloc (sizeof *p);
 838   memset (p, 0, sizeof *p);
 839
 840   p->name = name;
 841   p->type = type;
 842   p->kind = kind;
 843   p->val = val;
 844
 845   for (pp = &info->current_function->parameters;
 846        *pp != NULL;
 847        pp = &(*pp)->next)
 848     ;
 849   *pp = p;
 850
 851   return TRUE;
 852 }
 853
 854 /* End a function.  FIXME: This should handle function nesting.  */
 855
 856 bfd_boolean
 857 debug_end_function (void *handle, bfd_vma addr)
 858 {
 859   struct debug_handle *info = (struct debug_handle *) handle;
 860
 861   if (info->current_unit == NULL
 862       || info->current_block == NULL
 863       || info->current_function == NULL)
 864     {
 865       debug_error (_("debug_end_function: no current function"));
 866       return FALSE;
 867     }
 868
 869   if (info->current_block->parent != NULL)
 870     {
 871       debug_error (_("debug_end_function: some blocks were not closed"));
 872       return FALSE;
 873     }
 874
 875   info->current_block->end = addr;
 876
 877   info->current_function = NULL;
 878   info->current_block = NULL;
 879
 880   return TRUE;
 881 }
 882
 883 /* Start a block in a function.  All local information will be
 884    recorded in this block, until the matching call to debug_end_block.
 885    debug_start_block and debug_end_block may be nested.  The bfd_vma
 886    argument is the address at which this block starts.  */
 887
 888 bfd_boolean
 889 debug_start_block (void *handle, bfd_vma addr)
 890 {
 891   struct debug_handle *info = (struct debug_handle *) handle;
 892   struct debug_block *b, **pb;
 893
 894   /* We must always have a current block: debug_record_function sets
 895      one up.  */
 896   if (info->current_unit == NULL
 897       || info->current_block == NULL)
 898     {
 899       debug_error (_("debug_start_block: no current block"));
 900       return FALSE;
 901     }
 902
 903   b = (struct debug_block *) xmalloc (sizeof *b);
 904   memset (b, 0, sizeof *b);
 905
 906   b->parent = info->current_block;
 907   b->start = addr;
 908   b->end = (bfd_vma) -1;
 909
 910   /* This new block is a child of the current block.  */
 911   for (pb = &info->current_block->children;
 912        *pb != NULL;
 913        pb = &(*pb)->next)
 914     ;
 915   *pb = b;
 916
 917   info->current_block = b;
 918
 919   return TRUE;
 920 }
 921
 922 /* Finish a block in a function.  This matches the call to
 923    debug_start_block.  The argument is the address at which this block
 924    ends.  */
 925
 926 bfd_boolean
 927 debug_end_block (void *handle, bfd_vma addr)
 928 {
 929   struct debug_handle *info = (struct debug_handle *) handle;
 930   struct debug_block *parent;
 931
 932   if (info->current_unit == NULL
 933       || info->current_block == NULL)
 934     {
 935       debug_error (_("debug_end_block: no current block"));
 936       return FALSE;
 937     }
 938
 939   parent = info->current_block->parent;
 940   if (parent == NULL)
 941     {
 942       debug_error (_("debug_end_block: attempt to close top level block"));
 943       return FALSE;
 944     }
 945
 946   info->current_block->end = addr;
 947
 948   info->current_block = parent;
 949
 950   return TRUE;
 951 }
 952
 953 /* Associate a line number in the current source file and function
 954    with a given address.  */
 955
 956 bfd_boolean
 957 debug_record_line (void *handle, unsigned long lineno, bfd_vma addr)
 958 {
 959   struct debug_handle *info = (struct debug_handle *) handle;
 960   struct debug_lineno *l;
 961   unsigned int i;
 962
 963   if (info->current_unit == NULL)
 964     {
 965       debug_error (_("debug_record_line: no current unit"));
 966       return FALSE;
 967     }
 968
 969   l = info->current_lineno;
 970   if (l != NULL && l->file == info->current_file)
 971     {
 972       for (i = 0; i < DEBUG_LINENO_COUNT; i++)
 973         {
 974           if (l->linenos[i] == (unsigned long) -1)
 975             {
 976               l->linenos[i] = lineno;
 977               l->addrs[i] = addr;
 978               return TRUE;
 979             }
 980         }
 981     }
 982
 983   /* If we get here, then either 1) there is no current_lineno
 984      structure, which means this is the first line number in this
 985      compilation unit, 2) the current_lineno structure is for a
 986      different file, or 3) the current_lineno structure is full.
 987      Regardless, we want to allocate a new debug_lineno structure, put
 988      it in the right place, and make it the new current_lineno
 989      structure.  */
 990
 991   l = (struct debug_lineno *) xmalloc (sizeof *l);
 992   memset (l, 0, sizeof *l);
 993
 994   l->file = info->current_file;
 995   l->linenos[0] = lineno;
 996   l->addrs[0] = addr;
 997   for (i = 1; i < DEBUG_LINENO_COUNT; i++)
 998     l->linenos[i] = (unsigned long) -1;
 999
1000   if (info->current_lineno != NULL)
1001     info->current_lineno->next = l;
1002   else
1003     info->current_unit->linenos = l;
1004
1005   info->current_lineno = l;
1006
1007   return TRUE;
1008 }
1009
1010 /* Start a named common block.  This is a block of variables that may
1011    move in memory.  */
1012
1013 bfd_boolean
1014 debug_start_common_block (void *handle ATTRIBUTE_UNUSED,
1015                           const char *name ATTRIBUTE_UNUSED)
1016 {
1017   /* FIXME */
1018   debug_error (_("debug_start_common_block: not implemented"));
1019   return FALSE;
1020 }
1021
1022 /* End a named common block.  */
1023
1024 bfd_boolean
1025 debug_end_common_block (void *handle ATTRIBUTE_UNUSED,
1026                         const char *name ATTRIBUTE_UNUSED)
1027 {
1028   /* FIXME */
1029   debug_error (_("debug_end_common_block: not implemented"));
1030   return FALSE;
1031 }
1032
1033 /* Record a named integer constant.  */
1034
1035 bfd_boolean
1036 debug_record_int_const (void *handle, const char *name, bfd_vma val)
1037 {
1038   struct debug_handle *info = (struct debug_handle *) handle;
1039   struct debug_name *n;
1040
1041   if (name == NULL)
1042     return FALSE;
1043
1044   n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_INT_CONSTANT,
1045                                       DEBUG_LINKAGE_NONE);
1046   if (n == NULL)
1047     return FALSE;
1048
1049   n->u.int_constant = val;
1050
1051   return TRUE;
1052 }
1053
1054 /* Record a named floating point constant.  */
1055
1056 bfd_boolean
1057 debug_record_float_const (void *handle, const char *name, double val)
1058 {
1059   struct debug_handle *info = (struct debug_handle *) handle;
1060   struct debug_name *n;
1061
1062   if (name == NULL)
1063     return FALSE;
1064
1065   n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_FLOAT_CONSTANT,
1066                                       DEBUG_LINKAGE_NONE);
1067   if (n == NULL)
1068     return FALSE;
1069
1070   n->u.float_constant = val;
1071
1072   return TRUE;
1073 }
1074
1075 /* Record a typed constant with an integral value.  */
1076
1077 bfd_boolean
1078 debug_record_typed_const (void *handle, const char *name, debug_type type,
1079                           bfd_vma val)
1080 {
1081   struct debug_handle *info = (struct debug_handle *) handle;
1082   struct debug_name *n;
1083   struct debug_typed_constant *tc;
1084
1085   if (name == NULL || type == NULL)
1086     return FALSE;
1087
1088   n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_TYPED_CONSTANT,
1089                                       DEBUG_LINKAGE_NONE);
1090   if (n == NULL)
1091     return FALSE;
1092
1093   tc = (struct debug_typed_constant *) xmalloc (sizeof *tc);
1094   memset (tc, 0, sizeof *tc);
1095
1096   tc->type = type;
1097   tc->val = val;
1098
1099   n->u.typed_constant = tc;
1100
1101   return TRUE;
1102 }
1103
1104 /* Record a label.  */
1105
1106 bfd_boolean
1107 debug_record_label (void *handle ATTRIBUTE_UNUSED,
1108                     const char *name ATTRIBUTE_UNUSED,
1109                     debug_type type ATTRIBUTE_UNUSED,
1110                     bfd_vma addr ATTRIBUTE_UNUSED)
1111 {
1112   /* FIXME.  */
1113   debug_error (_("debug_record_label: not implemented"));
1114   return FALSE;
1115 }
1116
1117 /* Record a variable.  */
1118
1119 bfd_boolean
1120 debug_record_variable (void *handle, const char *name, debug_type type,
1121                        enum debug_var_kind kind, bfd_vma val)
1122 {
1123   struct debug_handle *info = (struct debug_handle *) handle;
1124   struct debug_namespace **nsp;
1125   enum debug_object_linkage linkage;
1126   struct debug_name *n;
1127   struct debug_variable *v;
1128
1129   if (name == NULL || type == NULL)
1130     return FALSE;
1131
1132   if (info->current_unit == NULL
1133       || info->current_file == NULL)
1134     {
1135       debug_error (_("debug_record_variable: no current file"));
1136       return FALSE;
1137     }
1138
1139   if (kind == DEBUG_GLOBAL || kind == DEBUG_STATIC)
1140     {
1141       nsp = &info->current_file->globals;
1142       if (kind == DEBUG_GLOBAL)
1143         linkage = DEBUG_LINKAGE_GLOBAL;
1144       else
1145         linkage = DEBUG_LINKAGE_STATIC;
1146     }
1147   else
1148     {
1149       if (info->current_block == NULL)
1150         nsp = &info->current_file->globals;
1151       else
1152         nsp = &info->current_block->locals;
1153       linkage = DEBUG_LINKAGE_AUTOMATIC;
1154     }
1155
1156   n = debug_add_to_namespace (info, nsp, name, DEBUG_OBJECT_VARIABLE, linkage);
1157   if (n == NULL)
1158     return FALSE;
1159
1160   v = (struct debug_variable *) xmalloc (sizeof *v);
1161   memset (v, 0, sizeof *v);
1162
1163   v->kind = kind;
1164   v->type = type;
1165   v->val = val;
1166
1167   n->u.variable = v;
1168
1169   return TRUE;
1170 }
1171
1172 /* Make a type with a given kind and size.  */
1173
1174 static struct debug_type_s *
1175 debug_make_type (struct debug_handle *info ATTRIBUTE_UNUSED,
1176                  enum debug_type_kind kind, unsigned int size)
1177 {
1178   struct debug_type_s *t;
1179
1180   t = (struct debug_type_s *) xmalloc (sizeof *t);
1181   memset (t, 0, sizeof *t);
1182
1183   t->kind = kind;
1184   t->size = size;
1185
1186   return t;
1187 }
1188
1189 /* Make an indirect type which may be used as a placeholder for a type
1190    which is referenced before it is defined.  */
1191
1192 debug_type
1193 debug_make_indirect_type (void *handle, debug_type *slot, const char *tag)
1194 {
1195   struct debug_handle *info = (struct debug_handle *) handle;
1196   struct debug_type_s *t;
1197   struct debug_indirect_type *i;
1198
1199   t = debug_make_type (info, DEBUG_KIND_INDIRECT, 0);
1200   if (t == NULL)
1201     return DEBUG_TYPE_NULL;
1202
1203   i = (struct debug_indirect_type *) xmalloc (sizeof *i);
1204   memset (i, 0, sizeof *i);
1205
1206   i->slot = slot;
1207   i->tag = tag;
1208
1209   t->u.kindirect = i;
1210
1211   return t;
1212 }
1213
1214 /* Make a void type.  There is only one of these.  */
1215
1216 debug_type
1217 debug_make_void_type (void *handle)
1218 {
1219   struct debug_handle *info = (struct debug_handle *) handle;
1220
1221   return debug_make_type (info, DEBUG_KIND_VOID, 0);
1222 }
1223
1224 /* Make an integer type of a given size.  The boolean argument is true
1225    if the integer is unsigned.  */
1226
1227 debug_type
1228 debug_make_int_type (void *handle, unsigned int size, bfd_boolean unsignedp)
1229 {
1230   struct debug_handle *info = (struct debug_handle *) handle;
1231   struct debug_type_s *t;
1232
1233   t = debug_make_type (info, DEBUG_KIND_INT, size);
1234   if (t == NULL)
1235     return DEBUG_TYPE_NULL;
1236
1237   t->u.kint = unsignedp;
1238
1239   return t;
1240 }
1241
1242 /* Make a floating point type of a given size.  FIXME: On some
1243    platforms, like an Alpha, you probably need to be able to specify
1244    the format.  */
1245
1246 debug_type
1247 debug_make_float_type (void *handle, unsigned int size)
1248 {
1249   struct debug_handle *info = (struct debug_handle *) handle;
1250
1251   return debug_make_type (info, DEBUG_KIND_FLOAT, size);
1252 }
1253
1254 /* Make a boolean type of a given size.  */
1255
1256 debug_type
1257 debug_make_bool_type (void *handle, unsigned int size)
1258 {
1259   struct debug_handle *info = (struct debug_handle *) handle;
1260
1261   return debug_make_type (info, DEBUG_KIND_BOOL, size);
1262 }
1263
1264 /* Make a complex type of a given size.  */
1265
1266 debug_type
1267 debug_make_complex_type (void *handle, unsigned int size)
1268 {
1269   struct debug_handle *info = (struct debug_handle *) handle;
1270
1271   return debug_make_type (info, DEBUG_KIND_COMPLEX, size);
1272 }
1273
1274 /* Make a structure type.  The second argument is true for a struct,
1275    false for a union.  The third argument is the size of the struct.
1276    The fourth argument is a NULL terminated array of fields.  */
1277
1278 debug_type
1279 debug_make_struct_type (void *handle, bfd_boolean structp, bfd_vma size,
1280                         debug_field *fields)
1281 {
1282   struct debug_handle *info = (struct debug_handle *) handle;
1283   struct debug_type_s *t;
1284   struct debug_class_type *c;
1285
1286   t = debug_make_type (info,
1287                        structp ? DEBUG_KIND_STRUCT : DEBUG_KIND_UNION,
1288                        size);
1289   if (t == NULL)
1290     return DEBUG_TYPE_NULL;
1291
1292   c = (struct debug_class_type *) xmalloc (sizeof *c);
1293   memset (c, 0, sizeof *c);
1294
1295   c->fields = fields;
1296
1297   t->u.kclass = c;
1298
1299   return t;
1300 }
1301
1302 /* Make an object type.  The first three arguments after the handle
1303    are the same as for debug_make_struct_type.  The next arguments are
1304    a NULL terminated array of base classes, a NULL terminated array of
1305    methods, the type of the object holding the virtual function table
1306    if it is not this object, and a boolean which is true if this
1307    object has its own virtual function table.  */
1308
1309 debug_type
1310 debug_make_object_type (void *handle, bfd_boolean structp, bfd_vma size,
1311                         debug_field *fields, debug_baseclass *baseclasses,
1312                         debug_method *methods, debug_type vptrbase,
1313                         bfd_boolean ownvptr)
1314 {
1315   struct debug_handle *info = (struct debug_handle *) handle;
1316   struct debug_type_s *t;
1317   struct debug_class_type *c;
1318
1319   t = debug_make_type (info,
1320                        structp ? DEBUG_KIND_CLASS : DEBUG_KIND_UNION_CLASS,
1321                        size);
1322   if (t == NULL)
1323     return DEBUG_TYPE_NULL;
1324
1325   c = (struct debug_class_type *) xmalloc (sizeof *c);
1326   memset (c, 0, sizeof *c);
1327
1328   c->fields = fields;
1329   c->baseclasses = baseclasses;
1330   c->methods = methods;
1331   if (ownvptr)
1332     c->vptrbase = t;
1333   else
1334     c->vptrbase = vptrbase;
1335
1336   t->u.kclass = c;
1337
1338   return t;
1339 }
1340
1341 /* Make an enumeration type.  The arguments are a null terminated
1342    array of strings, and an array of corresponding values.  */
1343
1344 debug_type
1345 debug_make_enum_type (void *handle, const char **names,
1346                       bfd_signed_vma *values)
1347 {
1348   struct debug_handle *info = (struct debug_handle *) handle;
1349   struct debug_type_s *t;
1350   struct debug_enum_type *e;
1351
1352   t = debug_make_type (info, DEBUG_KIND_ENUM, 0);
1353   if (t == NULL)
1354     return DEBUG_TYPE_NULL;
1355
1356   e = (struct debug_enum_type *) xmalloc (sizeof *e);
1357   memset (e, 0, sizeof *e);
1358
1359   e->names = names;
1360   e->values = values;
1361
1362   t->u.kenum = e;
1363
1364   return t;
1365 }
1366
1367 /* Make a pointer to a given type.  */
1368
1369 debug_type
1370 debug_make_pointer_type (void *handle, debug_type type)
1371 {
1372   struct debug_handle *info = (struct debug_handle *) handle;
1373   struct debug_type_s *t;
1374
1375   if (type == NULL)
1376     return DEBUG_TYPE_NULL;
1377
1378   if (type->pointer != DEBUG_TYPE_NULL)
1379     return type->pointer;
1380
1381   t = debug_make_type (info, DEBUG_KIND_POINTER, 0);
1382   if (t == NULL)
1383     return DEBUG_TYPE_NULL;
1384
1385   t->u.kpointer = type;
1386
1387   type->pointer = t;
1388
1389   return t;
1390 }
1391
1392 /* Make a function returning a given type.  FIXME: We should be able
1393    to record the parameter types.  */
1394
1395 debug_type
1396 debug_make_function_type (void *handle, debug_type type,
1397                           debug_type *arg_types, bfd_boolean varargs)
1398 {
1399   struct debug_handle *info = (struct debug_handle *) handle;
1400   struct debug_type_s *t;
1401   struct debug_function_type *f;
1402
1403   if (type == NULL)
1404     return DEBUG_TYPE_NULL;
1405
1406   t = debug_make_type (info, DEBUG_KIND_FUNCTION, 0);
1407   if (t == NULL)
1408     return DEBUG_TYPE_NULL;
1409
1410   f = (struct debug_function_type *) xmalloc (sizeof *f);
1411   memset (f, 0, sizeof *f);
1412
1413   f->return_type = type;
1414   f->arg_types = arg_types;
1415   f->varargs = varargs;
1416
1417   t->u.kfunction = f;
1418
1419   return t;
1420 }
1421
1422 /* Make a reference to a given type.  */
1423
1424 debug_type
1425 debug_make_reference_type (void *handle, debug_type type)
1426 {
1427   struct debug_handle *info = (struct debug_handle *) handle;
1428   struct debug_type_s *t;
1429
1430   if (type == NULL)
1431     return DEBUG_TYPE_NULL;
1432
1433   t = debug_make_type (info, DEBUG_KIND_REFERENCE, 0);
1434   if (t == NULL)
1435     return DEBUG_TYPE_NULL;
1436
1437   t->u.kreference = type;
1438
1439   return t;
1440 }
1441
1442 /* Make a range of a given type from a lower to an upper bound.  */
1443
1444 debug_type
1445 debug_make_range_type (void *handle, debug_type type, bfd_signed_vma lower,
1446                        bfd_signed_vma upper)
1447 {
1448   struct debug_handle *info = (struct debug_handle *) handle;
1449   struct debug_type_s *t;
1450   struct debug_range_type *r;
1451
1452   if (type == NULL)
1453     return DEBUG_TYPE_NULL;
1454
1455   t = debug_make_type (info, DEBUG_KIND_RANGE, 0);
1456   if (t == NULL)
1457     return DEBUG_TYPE_NULL;
1458
1459   r = (struct debug_range_type *) xmalloc (sizeof *r);
1460   memset (r, 0, sizeof *r);
1461
1462   r->type = type;
1463   r->lower = lower;
1464   r->upper = upper;
1465
1466   t->u.krange = r;
1467
1468   return t;
1469 }
1470
1471 /* Make an array type.  The second argument is the type of an element
1472    of the array.  The third argument is the type of a range of the
1473    array.  The fourth and fifth argument are the lower and upper
1474    bounds, respectively.  The sixth argument is true if this array is
1475    actually a string, as in C.  */
1476
1477 debug_type
1478 debug_make_array_type (void *handle, debug_type element_type,
1479                        debug_type range_type, bfd_signed_vma lower,
1480                        bfd_signed_vma upper, bfd_boolean stringp)
1481 {
1482   struct debug_handle *info = (struct debug_handle *) handle;
1483   struct debug_type_s *t;
1484   struct debug_array_type *a;
1485
1486   if (element_type == NULL || range_type == NULL)
1487     return DEBUG_TYPE_NULL;
1488
1489   t = debug_make_type (info, DEBUG_KIND_ARRAY, 0);
1490   if (t == NULL)
1491     return DEBUG_TYPE_NULL;
1492
1493   a = (struct debug_array_type *) xmalloc (sizeof *a);
1494   memset (a, 0, sizeof *a);
1495
1496   a->element_type = element_type;
1497   a->range_type = range_type;
1498   a->lower = lower;
1499   a->upper = upper;
1500   a->stringp = stringp;
1501
1502   t->u.karray = a;
1503
1504   return t;
1505 }
1506
1507 /* Make a set of a given type.  For example, a Pascal set type.  The
1508    boolean argument is true if this set is actually a bitstring, as in
1509    CHILL.  */
1510
1511 debug_type
1512 debug_make_set_type (void *handle, debug_type type, bfd_boolean bitstringp)
1513 {
1514   struct debug_handle *info = (struct debug_handle *) handle;
1515   struct debug_type_s *t;
1516   struct debug_set_type *s;
1517
1518   if (type == NULL)
1519     return DEBUG_TYPE_NULL;
1520
1521   t = debug_make_type (info, DEBUG_KIND_SET, 0);
1522   if (t == NULL)
1523     return DEBUG_TYPE_NULL;
1524
1525   s = (struct debug_set_type *) xmalloc (sizeof *s);
1526   memset (s, 0, sizeof *s);
1527
1528   s->type = type;
1529   s->bitstringp = bitstringp;
1530
1531   t->u.kset = s;
1532
1533   return t;
1534 }
1535
1536 /* Make a type for a pointer which is relative to an object.  The
1537    second argument is the type of the object to which the pointer is
1538    relative.  The third argument is the type that the pointer points
1539    to.  */
1540
1541 debug_type
1542 debug_make_offset_type (void *handle, debug_type base_type,
1543                         debug_type target_type)
1544 {
1545   struct debug_handle *info = (struct debug_handle *) handle;
1546   struct debug_type_s *t;
1547   struct debug_offset_type *o;
1548
1549   if (base_type == NULL || target_type == NULL)
1550     return DEBUG_TYPE_NULL;
1551
1552   t = debug_make_type (info, DEBUG_KIND_OFFSET, 0);
1553   if (t == NULL)
1554     return DEBUG_TYPE_NULL;
1555
1556   o = (struct debug_offset_type *) xmalloc (sizeof *o);
1557   memset (o, 0, sizeof *o);
1558
1559   o->base_type = base_type;
1560   o->target_type = target_type;
1561
1562   t->u.koffset = o;
1563
1564   return t;
1565 }
1566
1567 /* Make a type for a method function.  The second argument is the
1568    return type, the third argument is the domain, and the fourth
1569    argument is a NULL terminated array of argument types.  */
1570
1571 debug_type
1572 debug_make_method_type (void *handle, debug_type return_type,
1573                         debug_type domain_type, debug_type *arg_types,
1574                         bfd_boolean varargs)
1575 {
1576   struct debug_handle *info = (struct debug_handle *) handle;
1577   struct debug_type_s *t;
1578   struct debug_method_type *m;
1579
1580   if (return_type == NULL)
1581     return DEBUG_TYPE_NULL;
1582
1583   t = debug_make_type (info, DEBUG_KIND_METHOD, 0);
1584   if (t == NULL)
1585     return DEBUG_TYPE_NULL;
1586
1587   m = (struct debug_method_type *) xmalloc (sizeof *m);
1588   memset (m, 0, sizeof *m);
1589
1590   m->return_type = return_type;
1591   m->domain_type = domain_type;
1592   m->arg_types = arg_types;
1593   m->varargs = varargs;
1594
1595   t->u.kmethod = m;
1596
1597   return t;
1598 }
1599
1600 /* Make a const qualified version of a given type.  */
1601
1602 debug_type
1603 debug_make_const_type (void *handle, debug_type type)
1604 {
1605   struct debug_handle *info = (struct debug_handle *) handle;
1606   struct debug_type_s *t;
1607
1608   if (type == NULL)
1609     return DEBUG_TYPE_NULL;
1610
1611   t = debug_make_type (info, DEBUG_KIND_CONST, 0);
1612   if (t == NULL)
1613     return DEBUG_TYPE_NULL;
1614
1615   t->u.kconst = type;
1616
1617   return t;
1618 }
1619
1620 /* Make a volatile qualified version of a given type.  */
1621
1622 debug_type
1623 debug_make_volatile_type (void *handle, debug_type type)
1624 {
1625   struct debug_handle *info = (struct debug_handle *) handle;
1626   struct debug_type_s *t;
1627
1628   if (type == NULL)
1629     return DEBUG_TYPE_NULL;
1630
1631   t = debug_make_type (info, DEBUG_KIND_VOLATILE, 0);
1632   if (t == NULL)
1633     return DEBUG_TYPE_NULL;
1634
1635   t->u.kvolatile = type;
1636
1637   return t;
1638 }
1639
1640 /* Make an undefined tagged type.  For example, a struct which has
1641    been mentioned, but not defined.  */
1642
1643 debug_type
1644 debug_make_undefined_tagged_type (void *handle, const char *name,
1645                                   enum debug_type_kind kind)
1646 {
1647   struct debug_handle *info = (struct debug_handle *) handle;
1648   struct debug_type_s *t;
1649
1650   if (name == NULL)
1651     return DEBUG_TYPE_NULL;
1652
1653   switch (kind)
1654     {
1655     case DEBUG_KIND_STRUCT:
1656     case DEBUG_KIND_UNION:
1657     case DEBUG_KIND_CLASS:
1658     case DEBUG_KIND_UNION_CLASS:
1659     case DEBUG_KIND_ENUM:
1660       break;
1661
1662     default:
1663       debug_error (_("debug_make_undefined_type: unsupported kind"));
1664       return DEBUG_TYPE_NULL;
1665     }
1666
1667   t = debug_make_type (info, kind, 0);
1668   if (t == NULL)
1669     return DEBUG_TYPE_NULL;
1670
1671   return debug_tag_type (handle, name, t);
1672 }
1673
1674 /* Make a base class for an object.  The second argument is the base
1675    class type.  The third argument is the bit position of this base
1676    class in the object (always 0 unless doing multiple inheritance).
1677    The fourth argument is whether this is a virtual class.  The fifth
1678    argument is the visibility of the base class.  */
1679
1680 debug_baseclass
1681 debug_make_baseclass (void *handle ATTRIBUTE_UNUSED, debug_type type,
1682                       bfd_vma bitpos, bfd_boolean is_virtual,
1683                       enum debug_visibility visibility)
1684 {
1685   struct debug_baseclass_s *b;
1686
1687   b = (struct debug_baseclass_s *) xmalloc (sizeof *b);
1688   memset (b, 0, sizeof *b);
1689
1690   b->type = type;
1691   b->bitpos = bitpos;
1692   b->is_virtual = is_virtual;
1693   b->visibility = visibility;
1694
1695   return b;
1696 }
1697
1698 /* Make a field for a struct.  The second argument is the name.  The
1699    third argument is the type of the field.  The fourth argument is
1700    the bit position of the field.  The fifth argument is the size of
1701    the field (it may be zero).  The sixth argument is the visibility
1702    of the field.  */
1703
1704 debug_field
1705 debug_make_field (void *handle ATTRIBUTE_UNUSED, const char *name,
1706                   debug_type type, bfd_vma bitpos, bfd_vma bitsize,
1707                   enum debug_visibility visibility)
1708 {
1709   struct debug_field_s *f;
1710
1711   f = (struct debug_field_s *) xmalloc (sizeof *f);
1712   memset (f, 0, sizeof *f);
1713
1714   f->name = name;
1715   f->type = type;
1716   f->static_member = FALSE;
1717   f->u.f.bitpos = bitpos;
1718   f->u.f.bitsize = bitsize;
1719   f->visibility = visibility;
1720
1721   return f;
1722 }
1723
1724 /* Make a static member of an object.  The second argument is the
1725    name.  The third argument is the type of the member.  The fourth
1726    argument is the physical name of the member (i.e., the name as a
1727    global variable).  The fifth argument is the visibility of the
1728    member.  */
1729
1730 debug_field
1731 debug_make_static_member (void *handle ATTRIBUTE_UNUSED, const char *name,
1732                           debug_type type, const char *physname,
1733                           enum debug_visibility visibility)
1734 {
1735   struct debug_field_s *f;
1736
1737   f = (struct debug_field_s *) xmalloc (sizeof *f);
1738   memset (f, 0, sizeof *f);
1739
1740   f->name = name;
1741   f->type = type;
1742   f->static_member = TRUE;
1743   f->u.s.physname = physname;
1744   f->visibility = visibility;
1745
1746   return f;
1747 }
1748
1749 /* Make a method.  The second argument is the name, and the third
1750    argument is a NULL terminated array of method variants.  */
1751
1752 debug_method
1753 debug_make_method (void *handle ATTRIBUTE_UNUSED, const char *name,
1754                    debug_method_variant *variants)
1755 {
1756   struct debug_method_s *m;
1757
1758   m = (struct debug_method_s *) xmalloc (sizeof *m);
1759   memset (m, 0, sizeof *m);
1760
1761   m->name = name;
1762   m->variants = variants;
1763
1764   return m;
1765 }
1766
1767 /* Make a method argument.  The second argument is the real name of
1768    the function.  The third argument is the type of the function.  The
1769    fourth argument is the visibility.  The fifth argument is whether
1770    this is a const function.  The sixth argument is whether this is a
1771    volatile function.  The seventh argument is the offset in the
1772    virtual function table, if any.  The eighth argument is the virtual
1773    function context.  FIXME: Are the const and volatile arguments
1774    necessary?  Could we just use debug_make_const_type?  */
1775
1776 debug_method_variant
1777 debug_make_method_variant (void *handle ATTRIBUTE_UNUSED,
1778                            const char *physname, debug_type type,
1779                            enum debug_visibility visibility,
1780                            bfd_boolean constp, bfd_boolean volatilep,
1781                            bfd_vma voffset, debug_type context)
1782 {
1783   struct debug_method_variant_s *m;
1784
1785   m = (struct debug_method_variant_s *) xmalloc (sizeof *m);
1786   memset (m, 0, sizeof *m);
1787
1788   m->physname = physname;
1789   m->type = type;
1790   m->visibility = visibility;
1791   m->constp = constp;
1792   m->volatilep = volatilep;
1793   m->voffset = voffset;
1794   m->context = context;
1795
1796   return m;
1797 }
1798
1799 /* Make a static method argument.  The arguments are the same as for
1800    debug_make_method_variant, except that the last two are omitted
1801    since a static method can not also be virtual.  */
1802
1803 debug_method_variant
1804 debug_make_static_method_variant (void *handle ATTRIBUTE_UNUSED,
1805                                   const char *physname, debug_type type,
1806                                   enum debug_visibility visibility,
1807                                   bfd_boolean constp, bfd_boolean volatilep)
1808 {
1809   struct debug_method_variant_s *m;
1810
1811   m = (struct debug_method_variant_s *) xmalloc (sizeof *m);
1812   memset (m, 0, sizeof *m);
1813
1814   m->physname = physname;
1815   m->type = type;
1816   m->visibility = visibility;
1817   m->constp = constp;
1818   m->volatilep = volatilep;
1819   m->voffset = VOFFSET_STATIC_METHOD;
1820
1821   return m;
1822 }
1823
1824 /* Name a type.  */
1825
1826 debug_type
1827 debug_name_type (void *handle, const char *name, debug_type type)
1828 {
1829   struct debug_handle *info = (struct debug_handle *) handle;
1830   struct debug_type_s *t;
1831   struct debug_named_type *n;
1832   struct debug_name *nm;
1833
1834   if (name == NULL || type == NULL)
1835     return DEBUG_TYPE_NULL;
1836
1837   if (info->current_unit == NULL
1838       || info->current_file == NULL)
1839     {
1840       debug_error (_("debug_name_type: no current file"));
1841       return DEBUG_TYPE_NULL;
1842     }
1843
1844   t = debug_make_type (info, DEBUG_KIND_NAMED, 0);
1845   if (t == NULL)
1846     return DEBUG_TYPE_NULL;
1847
1848   n = (struct debug_named_type *) xmalloc (sizeof *n);
1849   memset (n, 0, sizeof *n);
1850
1851   n->type = type;
1852
1853   t->u.knamed = n;
1854
1855   /* We always add the name to the global namespace.  This is probably
1856      wrong in some cases, but it seems to be right for stabs.  FIXME.  */
1857
1858   nm = debug_add_to_namespace (info, &info->current_file->globals, name,
1859                                DEBUG_OBJECT_TYPE, DEBUG_LINKAGE_NONE);
1860   if (nm == NULL)
1861     return DEBUG_TYPE_NULL;
1862
1863   nm->u.type = t;
1864
1865   n->name = nm;
1866
1867   return t;
1868 }
1869
1870 /* Tag a type.  */
1871
1872 debug_type
1873 debug_tag_type (void *handle, const char *name, debug_type type)
1874 {
1875   struct debug_handle *info = (struct debug_handle *) handle;
1876   struct debug_type_s *t;
1877   struct debug_named_type *n;
1878   struct debug_name *nm;
1879
1880   if (name == NULL || type == NULL)
1881     return DEBUG_TYPE_NULL;
1882
1883   if (info->current_file == NULL)
1884     {
1885       debug_error (_("debug_tag_type: no current file"));
1886       return DEBUG_TYPE_NULL;
1887     }
1888
1889   if (type->kind == DEBUG_KIND_TAGGED)
1890     {
1891       if (strcmp (type->u.knamed->name->name, name) == 0)
1892         return type;
1893       debug_error (_("debug_tag_type: extra tag attempted"));
1894       return DEBUG_TYPE_NULL;
1895     }
1896
1897   t = debug_make_type (info, DEBUG_KIND_TAGGED, 0);
1898   if (t == NULL)
1899     return DEBUG_TYPE_NULL;
1900
1901   n = (struct debug_named_type *) xmalloc (sizeof *n);
1902   memset (n, 0, sizeof *n);
1903
1904   n->type = type;
1905
1906   t->u.knamed = n;
1907
1908   /* We keep a global namespace of tags for each compilation unit.  I
1909      don't know if that is the right thing to do.  */
1910
1911   nm = debug_add_to_namespace (info, &info->current_file->globals, name,
1912                                DEBUG_OBJECT_TAG, DEBUG_LINKAGE_NONE);
1913   if (nm == NULL)
1914     return DEBUG_TYPE_NULL;
1915
1916   nm->u.tag = t;
1917
1918   n->name = nm;
1919
1920   return t;
1921 }
1922
1923 /* Record the size of a given type.  */
1924
1925 bfd_boolean
1926 debug_record_type_size (void *handle ATTRIBUTE_UNUSED, debug_type type,
1927                         unsigned int size)
1928 {
1929   if (type->size != 0 && type->size != size)
1930     fprintf (stderr, _("Warning: changing type size from %d to %d\n"),
1931              type->size, size);
1932
1933   type->size = size;
1934
1935   return TRUE;
1936 }
1937
1938 /* Find a named type.  */
1939
1940 debug_type
1941 debug_find_named_type (void *handle, const char *name)
1942 {
1943   struct debug_handle *info = (struct debug_handle *) handle;
1944   struct debug_block *b;
1945   struct debug_file *f;
1946
1947   /* We only search the current compilation unit.  I don't know if
1948      this is right or not.  */
1949
1950   if (info->current_unit == NULL)
1951     {
1952       debug_error (_("debug_find_named_type: no current compilation unit"));
1953       return DEBUG_TYPE_NULL;
1954     }
1955
1956   for (b = info->current_block; b != NULL; b = b->parent)
1957     {
1958       if (b->locals != NULL)
1959         {
1960           struct debug_name *n;
1961
1962           for (n = b->locals->list; n != NULL; n = n->next)
1963             {
1964               if (n->kind == DEBUG_OBJECT_TYPE
1965                   && n->name[0] == name[0]
1966                   && strcmp (n->name, name) == 0)
1967                 return n->u.type;
1968             }
1969         }
1970     }
1971
1972   for (f = info->current_unit->files; f != NULL; f = f->next)
1973     {
1974       if (f->globals != NULL)
1975         {
1976           struct debug_name *n;
1977
1978           for (n = f->globals->list; n != NULL; n = n->next)
1979             {
1980               if (n->kind == DEBUG_OBJECT_TYPE
1981                   && n->name[0] == name[0]
1982                   && strcmp (n->name, name) == 0)
1983                 return n->u.type;
1984             }
1985         }
1986     }
1987
1988   return DEBUG_TYPE_NULL;
1989 }
1990
1991 /* Find a tagged type.  */
1992
1993 debug_type
1994 debug_find_tagged_type (void *handle, const char *name,
1995                         enum debug_type_kind kind)
1996 {
1997   struct debug_handle *info = (struct debug_handle *) handle;
1998   struct debug_unit *u;
1999
2000   /* We search the globals of all the compilation units.  I don't know
2001      if this is correct or not.  It would be easy to change.  */
2002
2003   for (u = info->units; u != NULL; u = u->next)
2004     {
2005       struct debug_file *f;
2006
2007       for (f = u->files; f != NULL; f = f->next)
2008         {
2009           struct debug_name *n;
2010
2011           if (f->globals != NULL)
2012             {
2013               for (n = f->globals->list; n != NULL; n = n->next)
2014                 {
2015                   if (n->kind == DEBUG_OBJECT_TAG
2016                       && (kind == DEBUG_KIND_ILLEGAL
2017                           || n->u.tag->kind == kind)
2018                       && n->name[0] == name[0]
2019                       && strcmp (n->name, name) == 0)
2020                     return n->u.tag;
2021                 }
2022             }
2023         }
2024     }
2025
2026   return DEBUG_TYPE_NULL;
2027 }
2028
2029 /* Get a base type.  We build a linked list on the stack to avoid
2030    crashing if the type is defined circularly.  */
2031
2032 static struct debug_type_s *
2033 debug_get_real_type (void *handle, debug_type type,
2034                      struct debug_type_real_list *list)
2035 {
2036   struct debug_type_real_list *l;
2037   struct debug_type_real_list rl;
2038
2039   switch (type->kind)
2040     {
2041     default:
2042       return type;
2043
2044     case DEBUG_KIND_INDIRECT:
2045     case DEBUG_KIND_NAMED:
2046     case DEBUG_KIND_TAGGED:
2047       break;
2048     }
2049
2050   for (l = list; l != NULL; l = l->next)
2051     {
2052       if (l->t == type || l == l->next)
2053         {
2054           fprintf (stderr,
2055                    _("debug_get_real_type: circular debug information for %s\n"),
2056                    debug_get_type_name (handle, type));
2057           return NULL;
2058         }
2059     }
2060
2061   rl.next = list;
2062   rl.t = type;
2063
2064   switch (type->kind)
2065     {
2066       /* The default case is just here to avoid warnings.  */
2067     default:
2068     case DEBUG_KIND_INDIRECT:
2069       if (*type->u.kindirect->slot != NULL)
2070         return debug_get_real_type (handle, *type->u.kindirect->slot, &rl);
2071       return type;
2072     case DEBUG_KIND_NAMED:
2073     case DEBUG_KIND_TAGGED:
2074       return debug_get_real_type (handle, type->u.knamed->type, &rl);
2075     }
2076   /*NOTREACHED*/
2077 }
2078
2079 /* Get the kind of a type.  */
2080
2081 enum debug_type_kind
2082 debug_get_type_kind (void *handle, debug_type type)
2083 {
2084   if (type == NULL)
2085     return DEBUG_KIND_ILLEGAL;
2086   type = debug_get_real_type (handle, type, NULL);
2087   if (type == NULL)
2088     return DEBUG_KIND_ILLEGAL;
2089   return type->kind;
2090 }
2091
2092 /* Get the name of a type.  */
2093
2094 const char *
2095 debug_get_type_name (void *handle, debug_type type)
2096 {
2097   if (type->kind == DEBUG_KIND_INDIRECT)
2098     {
2099       if (*type->u.kindirect->slot != NULL)
2100         return debug_get_type_name (handle, *type->u.kindirect->slot);
2101       return type->u.kindirect->tag;
2102     }
2103   if (type->kind == DEBUG_KIND_NAMED
2104       || type->kind == DEBUG_KIND_TAGGED)
2105     return type->u.knamed->name->name;
2106   return NULL;
2107 }
2108
2109 /* Get the size of a type.  */
2110
2111 bfd_vma
2112 debug_get_type_size (void *handle, debug_type type)
2113 {
2114   if (type == NULL)
2115     return 0;
2116
2117   /* We don't call debug_get_real_type, because somebody might have
2118      called debug_record_type_size on a named or indirect type.  */
2119
2120   if (type->size != 0)
2121     return type->size;
2122
2123   switch (type->kind)
2124     {
2125     default:
2126       return 0;
2127     case DEBUG_KIND_INDIRECT:
2128       if (*type->u.kindirect->slot != NULL)
2129         return debug_get_type_size (handle, *type->u.kindirect->slot);
2130       return 0;
2131     case DEBUG_KIND_NAMED:
2132     case DEBUG_KIND_TAGGED:
2133       return debug_get_type_size (handle, type->u.knamed->type);
2134     }
2135   /*NOTREACHED*/
2136 }
2137
2138 /* Get the return type of a function or method type.  */
2139
2140 debug_type
2141 debug_get_return_type (void *handle, debug_type type)
2142 {
2143   if (type == NULL)
2144     return DEBUG_TYPE_NULL;
2145
2146   type = debug_get_real_type (handle, type, NULL);
2147   if (type == NULL)
2148     return DEBUG_TYPE_NULL;
2149
2150   switch (type->kind)
2151     {
2152     default:
2153       return DEBUG_TYPE_NULL;
2154     case DEBUG_KIND_FUNCTION:
2155       return type->u.kfunction->return_type;
2156     case DEBUG_KIND_METHOD:
2157       return type->u.kmethod->return_type;
2158     }
2159   /*NOTREACHED*/
2160 }
2161
2162 /* Get the parameter types of a function or method type (except that
2163    we don't currently store the parameter types of a function).  */
2164
2165 const debug_type *
2166 debug_get_parameter_types (void *handle, debug_type type,
2167                            bfd_boolean *pvarargs)
2168 {
2169   if (type == NULL)
2170     return NULL;
2171
2172   type = debug_get_real_type (handle, type, NULL);
2173   if (type == NULL)
2174     return NULL;
2175
2176   switch (type->kind)
2177     {
2178     default:
2179       return NULL;
2180     case DEBUG_KIND_FUNCTION:
2181       *pvarargs = type->u.kfunction->varargs;
2182       return type->u.kfunction->arg_types;
2183     case DEBUG_KIND_METHOD:
2184       *pvarargs = type->u.kmethod->varargs;
2185       return type->u.kmethod->arg_types;
2186     }
2187   /*NOTREACHED*/
2188 }
2189
2190 /* Get the target type of a type.  */
2191
2192 debug_type
2193 debug_get_target_type (void *handle, debug_type type)
2194 {
2195   if (type == NULL)
2196     return NULL;
2197
2198   type = debug_get_real_type (handle, type, NULL);
2199   if (type == NULL)
2200     return NULL;
2201
2202   switch (type->kind)
2203     {
2204     default:
2205       return NULL;
2206     case DEBUG_KIND_POINTER:
2207       return type->u.kpointer;
2208     case DEBUG_KIND_REFERENCE:
2209       return type->u.kreference;
2210     case DEBUG_KIND_CONST:
2211       return type->u.kconst;
2212     case DEBUG_KIND_VOLATILE:
2213       return type->u.kvolatile;
2214     }
2215   /*NOTREACHED*/
2216 }
2217
2218 /* Get the NULL terminated array of fields for a struct, union, or
2219    class.  */
2220
2221 const debug_field *
2222 debug_get_fields (void *handle, debug_type type)
2223 {
2224   if (type == NULL)
2225     return NULL;
2226
2227   type = debug_get_real_type (handle, type, NULL);
2228   if (type == NULL)
2229     return NULL;
2230
2231   switch (type->kind)
2232     {
2233     default:
2234       return NULL;
2235     case DEBUG_KIND_STRUCT:
2236     case DEBUG_KIND_UNION:
2237     case DEBUG_KIND_CLASS:
2238     case DEBUG_KIND_UNION_CLASS:
2239       return type->u.kclass->fields;
2240     }
2241   /*NOTREACHED*/
2242 }
2243
2244 /* Get the type of a field.  */
2245
2246 debug_type
2247 debug_get_field_type (void *handle ATTRIBUTE_UNUSED, debug_field field)
2248 {
2249   if (field == NULL)
2250     return NULL;
2251   return field->type;
2252 }
2253
2254 /* Get the name of a field.  */
2255
2256 const char *
2257 debug_get_field_name (void *handle ATTRIBUTE_UNUSED, debug_field field)
2258 {
2259   if (field == NULL)
2260     return NULL;
2261   return field->name;
2262 }
2263
2264 /* Get the bit position of a field.  */
2265
2266 bfd_vma
2267 debug_get_field_bitpos (void *handle ATTRIBUTE_UNUSED, debug_field field)
2268 {
2269   if (field == NULL || field->static_member)
2270     return (bfd_vma) -1;
2271   return field->u.f.bitpos;
2272 }
2273
2274 /* Get the bit size of a field.  */
2275
2276 bfd_vma
2277 debug_get_field_bitsize (void *handle ATTRIBUTE_UNUSED, debug_field field)
2278 {
2279   if (field == NULL || field->static_member)
2280     return (bfd_vma) -1;
2281   return field->u.f.bitsize;
2282 }
2283
2284 /* Get the visibility of a field.  */
2285
2286 enum debug_visibility
2287 debug_get_field_visibility (void *handle ATTRIBUTE_UNUSED, debug_field field)
2288 {
2289   if (field == NULL)
2290     return DEBUG_VISIBILITY_IGNORE;
2291   return field->visibility;
2292 }
2293
2294 /* Get the physical name of a field.  */
2295
2296 const char *
2297 debug_get_field_physname (void *handle ATTRIBUTE_UNUSED, debug_field field)
2298 {
2299   if (field == NULL || ! field->static_member)
2300     return NULL;
2301   return field->u.s.physname;
2302 }
2303 \f
2304 /* Write out the debugging information.  This is given a handle to
2305    debugging information, and a set of function pointers to call.  */
2306
2307 bfd_boolean
2308 debug_write (void *handle, const struct debug_write_fns *fns, void *fhandle)
2309 {
2310   struct debug_handle *info = (struct debug_handle *) handle;
2311   struct debug_unit *u;
2312
2313   /* We use a mark to tell whether we have already written out a
2314      particular name.  We use an integer, so that we don't have to
2315      clear the mark fields if we happen to write out the same
2316      information more than once.  */
2317   ++info->mark;
2318
2319   /* The base_id field holds an ID value which will never be used, so
2320      that we can tell whether we have assigned an ID during this call
2321      to debug_write.  */
2322   info->base_id = info->class_id;
2323
2324   /* We keep a linked list of classes for which was have assigned ID's
2325      during this call to debug_write.  */
2326   info->id_list = NULL;
2327
2328   for (u = info->units; u != NULL; u = u->next)
2329     {
2330       struct debug_file *f;
2331       bfd_boolean first_file;
2332
2333       info->current_write_lineno = u->linenos;
2334       info->current_write_lineno_index = 0;
2335
2336       if (! (*fns->start_compilation_unit) (fhandle, u->files->filename))
2337         return FALSE;
2338
2339       first_file = TRUE;
2340       for (f = u->files; f != NULL; f = f->next)
2341         {
2342           struct debug_name *n;
2343
2344           if (first_file)
2345             first_file = FALSE;
2346           else if (! (*fns->start_source) (fhandle, f->filename))
2347             return FALSE;
2348
2349           if (f->globals != NULL)
2350             for (n = f->globals->list; n != NULL; n = n->next)
2351               if (! debug_write_name (info, fns, fhandle, n))
2352                 return FALSE;
2353         }
2354
2355       /* Output any line number information which hasn't already been
2356          handled.  */
2357       if (! debug_write_linenos (info, fns, fhandle, (bfd_vma) -1))
2358         return FALSE;
2359     }
2360
2361   return TRUE;
2362 }
2363
2364 /* Write out an element in a namespace.  */
2365
2366 static bfd_boolean
2367 debug_write_name (struct debug_handle *info,
2368                   const struct debug_write_fns *fns, void *fhandle,
2369                   struct debug_name *n)
2370 {
2371   switch (n->kind)
2372     {
2373     case DEBUG_OBJECT_TYPE:
2374       if (! debug_write_type (info, fns, fhandle, n->u.type, n)
2375           || ! (*fns->typdef) (fhandle, n->name))
2376         return FALSE;
2377       return TRUE;
2378     case DEBUG_OBJECT_TAG:
2379       if (! debug_write_type (info, fns, fhandle, n->u.tag, n))
2380         return FALSE;
2381       return (*fns->tag) (fhandle, n->name);
2382     case DEBUG_OBJECT_VARIABLE:
2383       if (! debug_write_type (info, fns, fhandle, n->u.variable->type,
2384                               (struct debug_name *) NULL))
2385         return FALSE;
2386       return (*fns->variable) (fhandle, n->name, n->u.variable->kind,
2387                                n->u.variable->val);
2388     case DEBUG_OBJECT_FUNCTION:
2389       return debug_write_function (info, fns, fhandle, n->name,
2390                                    n->linkage, n->u.function);
2391     case DEBUG_OBJECT_INT_CONSTANT:
2392       return (*fns->int_constant) (fhandle, n->name, n->u.int_constant);
2393     case DEBUG_OBJECT_FLOAT_CONSTANT:
2394       return (*fns->float_constant) (fhandle, n->name, n->u.float_constant);
2395     case DEBUG_OBJECT_TYPED_CONSTANT:
2396       if (! debug_write_type (info, fns, fhandle, n->u.typed_constant->type,
2397                               (struct debug_name *) NULL))
2398         return FALSE;
2399       return (*fns->typed_constant) (fhandle, n->name,
2400                                      n->u.typed_constant->val);
2401     default:
2402       abort ();
2403       return FALSE;
2404     }
2405   /*NOTREACHED*/
2406 }
2407
2408 /* Write out a type.  If the type is DEBUG_KIND_NAMED or
2409    DEBUG_KIND_TAGGED, then the name argument is the name for which we
2410    are about to call typedef or tag.  If the type is anything else,
2411    then the name argument is a tag from a DEBUG_KIND_TAGGED type which
2412    points to this one.  */
2413
2414 static bfd_boolean
2415 debug_write_type (struct debug_handle *info,
2416                   const struct debug_write_fns *fns, void *fhandle,
2417                   struct debug_type_s *type, struct debug_name *name)
2418 {
2419   unsigned int i;
2420   int is;
2421   const char *tag = NULL;
2422
2423   /* If we have a name for this type, just output it.  We only output
2424      typedef names after they have been defined.  We output type tags
2425      whenever we are not actually defining them.  */
2426   if ((type->kind == DEBUG_KIND_NAMED
2427        || type->kind == DEBUG_KIND_TAGGED)
2428       && (type->u.knamed->name->mark == info->mark
2429           || (type->kind == DEBUG_KIND_TAGGED
2430               && type->u.knamed->name != name)))
2431     {
2432       if (type->kind == DEBUG_KIND_NAMED)
2433         return (*fns->typedef_type) (fhandle, type->u.knamed->name->name);
2434       else
2435         {
2436           struct debug_type_s *real;
2437           unsigned int id;
2438
2439           real = debug_get_real_type ((void *) info, type, NULL);
2440           if (real == NULL)
2441             return (*fns->empty_type) (fhandle);
2442           id = 0;
2443           if ((real->kind == DEBUG_KIND_STRUCT
2444                || real->kind == DEBUG_KIND_UNION
2445                || real->kind == DEBUG_KIND_CLASS
2446                || real->kind == DEBUG_KIND_UNION_CLASS)
2447               && real->u.kclass != NULL)
2448             {
2449               if (real->u.kclass->id <= info->base_id)
2450                 {
2451                   if (! debug_set_class_id (info,
2452                                             type->u.knamed->name->name,
2453                                             real))
2454                     return FALSE;
2455                 }
2456               id = real->u.kclass->id;
2457             }
2458
2459           return (*fns->tag_type) (fhandle, type->u.knamed->name->name, id,
2460                                    real->kind);
2461         }
2462     }
2463
2464   /* Mark the name after we have already looked for a known name, so
2465      that we don't just define a type in terms of itself.  We need to
2466      mark the name here so that a struct containing a pointer to
2467      itself will work.  */
2468   if (name != NULL)
2469     name->mark = info->mark;
2470
2471   if (name != NULL
2472       && type->kind != DEBUG_KIND_NAMED
2473       && type->kind != DEBUG_KIND_TAGGED)
2474     {
2475       assert (name->kind == DEBUG_OBJECT_TAG);
2476       tag = name->name;
2477     }
2478
2479   switch (type->kind)
2480     {
2481     case DEBUG_KIND_ILLEGAL:
2482       debug_error (_("debug_write_type: illegal type encountered"));
2483       return FALSE;
2484     case DEBUG_KIND_INDIRECT:
2485       if (*type->u.kindirect->slot == DEBUG_TYPE_NULL)
2486         return (*fns->empty_type) (fhandle);
2487       return debug_write_type (info, fns, fhandle, *type->u.kindirect->slot,
2488                                name);
2489     case DEBUG_KIND_VOID:
2490       return (*fns->void_type) (fhandle);
2491     case DEBUG_KIND_INT:
2492       return (*fns->int_type) (fhandle, type->size, type->u.kint);
2493     case DEBUG_KIND_FLOAT:
2494       return (*fns->float_type) (fhandle, type->size);
2495     case DEBUG_KIND_COMPLEX:
2496       return (*fns->complex_type) (fhandle, type->size);
2497     case DEBUG_KIND_BOOL:
2498       return (*fns->bool_type) (fhandle, type->size);
2499     case DEBUG_KIND_STRUCT:
2500     case DEBUG_KIND_UNION:
2501       if (type->u.kclass != NULL)
2502         {
2503           if (type->u.kclass->id <= info->base_id)
2504             {
2505               if (! debug_set_class_id (info, tag, type))
2506                 return FALSE;
2507             }
2508
2509           if (info->mark == type->u.kclass->mark)
2510             {
2511               /* We are currently outputting this struct, or we have
2512                  already output it.  I don't know if this can happen,
2513                  but it can happen for a class.  */
2514               assert (type->u.kclass->id > info->base_id);
2515               return (*fns->tag_type) (fhandle, tag, type->u.kclass->id,
2516                                        type->kind);
2517             }
2518           type->u.kclass->mark = info->mark;
2519         }
2520
2521       if (! (*fns->start_struct_type) (fhandle, tag,
2522                                        (type->u.kclass != NULL
2523                                         ? type->u.kclass->id
2524                                         : 0),
2525                                        type->kind == DEBUG_KIND_STRUCT,
2526                                        type->size))
2527         return FALSE;
2528       if (type->u.kclass != NULL
2529           && type->u.kclass->fields != NULL)
2530         {
2531           for (i = 0; type->u.kclass->fields[i] != NULL; i++)
2532             {
2533               struct debug_field_s *f;
2534
2535               f = type->u.kclass->fields[i];
2536               if (! debug_write_type (info, fns, fhandle, f->type,
2537                                       (struct debug_name *) NULL)
2538                   || ! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
2539                                              f->u.f.bitsize, f->visibility))
2540                 return FALSE;
2541             }
2542         }
2543       return (*fns->end_struct_type) (fhandle);
2544     case DEBUG_KIND_CLASS:
2545     case DEBUG_KIND_UNION_CLASS:
2546       return debug_write_class_type (info, fns, fhandle, type, tag);
2547     case DEBUG_KIND_ENUM:
2548       if (type->u.kenum == NULL)
2549         return (*fns->enum_type) (fhandle, tag, (const char **) NULL,
2550                                   (bfd_signed_vma *) NULL);
2551       return (*fns->enum_type) (fhandle, tag, type->u.kenum->names,
2552                                 type->u.kenum->values);
2553     case DEBUG_KIND_POINTER:
2554       if (! debug_write_type (info, fns, fhandle, type->u.kpointer,
2555                               (struct debug_name *) NULL))
2556         return FALSE;
2557       return (*fns->pointer_type) (fhandle);
2558     case DEBUG_KIND_FUNCTION:
2559       if (! debug_write_type (info, fns, fhandle,
2560                               type->u.kfunction->return_type,
2561                               (struct debug_name *) NULL))
2562         return FALSE;
2563       if (type->u.kfunction->arg_types == NULL)
2564         is = -1;
2565       else
2566         {
2567           for (is = 0; type->u.kfunction->arg_types[is] != NULL; is++)
2568             if (! debug_write_type (info, fns, fhandle,
2569                                     type->u.kfunction->arg_types[is],
2570                                     (struct debug_name *) NULL))
2571               return FALSE;
2572         }
2573       return (*fns->function_type) (fhandle, is,
2574                                     type->u.kfunction->varargs);
2575     case DEBUG_KIND_REFERENCE:
2576       if (! debug_write_type (info, fns, fhandle, type->u.kreference,
2577                               (struct debug_name *) NULL))
2578         return FALSE;
2579       return (*fns->reference_type) (fhandle);
2580     case DEBUG_KIND_RANGE:
2581       if (! debug_write_type (info, fns, fhandle, type->u.krange->type,
2582                               (struct debug_name *) NULL))
2583         return FALSE;
2584       return (*fns->range_type) (fhandle, type->u.krange->lower,
2585                                  type->u.krange->upper);
2586     case DEBUG_KIND_ARRAY:
2587       if (! debug_write_type (info, fns, fhandle, type->u.karray->element_type,
2588                               (struct debug_name *) NULL)
2589           || ! debug_write_type (info, fns, fhandle,
2590                                  type->u.karray->range_type,
2591                                  (struct debug_name *) NULL))
2592         return FALSE;
2593       return (*fns->array_type) (fhandle, type->u.karray->lower,
2594                                  type->u.karray->upper,
2595                                  type->u.karray->stringp);
2596     case DEBUG_KIND_SET:
2597       if (! debug_write_type (info, fns, fhandle, type->u.kset->type,
2598                               (struct debug_name *) NULL))
2599         return FALSE;
2600       return (*fns->set_type) (fhandle, type->u.kset->bitstringp);
2601     case DEBUG_KIND_OFFSET:
2602       if (! debug_write_type (info, fns, fhandle, type->u.koffset->base_type,
2603                               (struct debug_name *) NULL)
2604           || ! debug_write_type (info, fns, fhandle,
2605                                  type->u.koffset->target_type,
2606                                  (struct debug_name *) NULL))
2607         return FALSE;
2608       return (*fns->offset_type) (fhandle);
2609     case DEBUG_KIND_METHOD:
2610       if (! debug_write_type (info, fns, fhandle,
2611                               type->u.kmethod->return_type,
2612                               (struct debug_name *) NULL))
2613         return FALSE;
2614       if (type->u.kmethod->arg_types == NULL)
2615         is = -1;
2616       else
2617         {
2618           for (is = 0; type->u.kmethod->arg_types[is] != NULL; is++)
2619             if (! debug_write_type (info, fns, fhandle,
2620                                     type->u.kmethod->arg_types[is],
2621                                     (struct debug_name *) NULL))
2622               return FALSE;
2623         }
2624       if (type->u.kmethod->domain_type != NULL)
2625         {
2626           if (! debug_write_type (info, fns, fhandle,
2627                                   type->u.kmethod->domain_type,
2628                                   (struct debug_name *) NULL))
2629             return FALSE;
2630         }
2631       return (*fns->method_type) (fhandle,
2632                                   type->u.kmethod->domain_type != NULL,
2633                                   is,
2634                                   type->u.kmethod->varargs);
2635     case DEBUG_KIND_CONST:
2636       if (! debug_write_type (info, fns, fhandle, type->u.kconst,
2637                               (struct debug_name *) NULL))
2638         return FALSE;
2639       return (*fns->const_type) (fhandle);
2640     case DEBUG_KIND_VOLATILE:
2641       if (! debug_write_type (info, fns, fhandle, type->u.kvolatile,
2642                               (struct debug_name *) NULL))
2643         return FALSE;
2644       return (*fns->volatile_type) (fhandle);
2645     case DEBUG_KIND_NAMED:
2646       return debug_write_type (info, fns, fhandle, type->u.knamed->type,
2647                                (struct debug_name *) NULL);
2648     case DEBUG_KIND_TAGGED:
2649       return debug_write_type (info, fns, fhandle, type->u.knamed->type,
2650                                type->u.knamed->name);
2651     default:
2652       abort ();
2653       return FALSE;
2654     }
2655 }
2656
2657 /* Write out a class type.  */
2658
2659 static bfd_boolean
2660 debug_write_class_type (struct debug_handle *info,
2661                         const struct debug_write_fns *fns, void *fhandle,
2662                         struct debug_type_s *type, const char *tag)
2663 {
2664   unsigned int i;
2665   unsigned int id;
2666   struct debug_type_s *vptrbase;
2667
2668   if (type->u.kclass == NULL)
2669     {
2670       id = 0;
2671       vptrbase = NULL;
2672     }
2673   else
2674     {
2675       if (type->u.kclass->id <= info->base_id)
2676         {
2677           if (! debug_set_class_id (info, tag, type))
2678             return FALSE;
2679         }
2680
2681       if (info->mark == type->u.kclass->mark)
2682         {
2683           /* We are currently outputting this class, or we have
2684              already output it.  This can happen when there are
2685              methods for an anonymous class.  */
2686           assert (type->u.kclass->id > info->base_id);
2687           return (*fns->tag_type) (fhandle, tag, type->u.kclass->id,
2688                                    type->kind);
2689         }
2690       type->u.kclass->mark = info->mark;
2691       id = type->u.kclass->id;
2692
2693       vptrbase = type->u.kclass->vptrbase;
2694       if (vptrbase != NULL && vptrbase != type)
2695         {
2696           if (! debug_write_type (info, fns, fhandle, vptrbase,
2697                                   (struct debug_name *) NULL))
2698             return FALSE;
2699         }
2700     }
2701
2702   if (! (*fns->start_class_type) (fhandle, tag, id,
2703                                   type->kind == DEBUG_KIND_CLASS,
2704                                   type->size,
2705                                   vptrbase != NULL,
2706                                   vptrbase == type))
2707     return FALSE;
2708
2709   if (type->u.kclass != NULL)
2710     {
2711       if (type->u.kclass->fields != NULL)
2712         {
2713           for (i = 0; type->u.kclass->fields[i] != NULL; i++)
2714             {
2715               struct debug_field_s *f;
2716
2717               f = type->u.kclass->fields[i];
2718               if (! debug_write_type (info, fns, fhandle, f->type,
2719                                       (struct debug_name *) NULL))
2720                 return FALSE;
2721               if (f->static_member)
2722                 {
2723                   if (! (*fns->class_static_member) (fhandle, f->name,
2724                                                      f->u.s.physname,
2725                                                      f->visibility))
2726                     return FALSE;
2727                 }
2728               else
2729                 {
2730                   if (! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
2731                                               f->u.f.bitsize, f->visibility))
2732                     return FALSE;
2733                 }
2734             }
2735         }
2736
2737       if (type->u.kclass->baseclasses != NULL)
2738         {
2739           for (i = 0; type->u.kclass->baseclasses[i] != NULL; i++)
2740             {
2741               struct debug_baseclass_s *b;
2742
2743               b = type->u.kclass->baseclasses[i];
2744               if (! debug_write_type (info, fns, fhandle, b->type,
2745                                       (struct debug_name *) NULL))
2746                 return FALSE;
2747               if (! (*fns->class_baseclass) (fhandle, b->bitpos, b->is_virtual,
2748                                              b->visibility))
2749                 return FALSE;
2750             }
2751         }
2752
2753       if (type->u.kclass->methods != NULL)
2754         {
2755           for (i = 0; type->u.kclass->methods[i] != NULL; i++)
2756             {
2757               struct debug_method_s *m;
2758               unsigned int j;
2759
2760               m = type->u.kclass->methods[i];
2761               if (! (*fns->class_start_method) (fhandle, m->name))
2762                 return FALSE;
2763               for (j = 0; m->variants[j] != NULL; j++)
2764                 {
2765                   struct debug_method_variant_s *v;
2766
2767                   v = m->variants[j];
2768                   if (v->context != NULL)
2769                     {
2770                       if (! debug_write_type (info, fns, fhandle, v->context,
2771                                               (struct debug_name *) NULL))
2772                         return FALSE;
2773                     }
2774                   if (! debug_write_type (info, fns, fhandle, v->type,
2775                                           (struct debug_name *) NULL))
2776                     return FALSE;
2777                   if (v->voffset != VOFFSET_STATIC_METHOD)
2778                     {
2779                       if (! (*fns->class_method_variant) (fhandle, v->physname,
2780                                                           v->visibility,
2781                                                           v->constp,
2782                                                           v->volatilep,
2783                                                           v->voffset,
2784                                                           v->context != NULL))
2785                         return FALSE;
2786                     }
2787                   else
2788                     {
2789                       if (! (*fns->class_static_method_variant) (fhandle,
2790                                                                  v->physname,
2791                                                                  v->visibility,
2792                                                                  v->constp,
2793                                                                  v->volatilep))
2794                         return FALSE;
2795                     }
2796                 }
2797               if (! (*fns->class_end_method) (fhandle))
2798                 return FALSE;
2799             }
2800         }
2801     }
2802
2803   return (*fns->end_class_type) (fhandle);
2804 }
2805
2806 /* Write out information for a function.  */
2807
2808 static bfd_boolean
2809 debug_write_function (struct debug_handle *info,
2810                       const struct debug_write_fns *fns, void *fhandle,
2811                       const char *name, enum debug_object_linkage linkage,
2812                       struct debug_function *function)
2813 {
2814   struct debug_parameter *p;
2815   struct debug_block *b;
2816
2817   if (! debug_write_linenos (info, fns, fhandle, function->blocks->start))
2818     return FALSE;
2819
2820   if (! debug_write_type (info, fns, fhandle, function->return_type,
2821                           (struct debug_name *) NULL))
2822     return FALSE;
2823
2824   if (! (*fns->start_function) (fhandle, name,
2825                                 linkage == DEBUG_LINKAGE_GLOBAL))
2826     return FALSE;
2827
2828   for (p = function->parameters; p != NULL; p = p->next)
2829     {
2830       if (! debug_write_type (info, fns, fhandle, p->type,
2831                               (struct debug_name *) NULL)
2832           || ! (*fns->function_parameter) (fhandle, p->name, p->kind, p->val))
2833         return FALSE;
2834     }
2835
2836   for (b = function->blocks; b != NULL; b = b->next)
2837     {
2838       if (! debug_write_block (info, fns, fhandle, b))
2839         return FALSE;
2840     }
2841
2842   return (*fns->end_function) (fhandle);
2843 }
2844
2845 /* Write out information for a block.  */
2846
2847 static bfd_boolean
2848 debug_write_block (struct debug_handle *info,
2849                    const struct debug_write_fns *fns, void *fhandle,
2850                    struct debug_block *block)
2851 {
2852   struct debug_name *n;
2853   struct debug_block *b;
2854
2855   if (! debug_write_linenos (info, fns, fhandle, block->start))
2856     return FALSE;
2857
2858   /* I can't see any point to writing out a block with no local
2859      variables, so we don't bother, except for the top level block.  */
2860   if (block->locals != NULL || block->parent == NULL)
2861     {
2862       if (! (*fns->start_block) (fhandle, block->start))
2863         return FALSE;
2864     }
2865
2866   if (block->locals != NULL)
2867     {
2868       for (n = block->locals->list; n != NULL; n = n->next)
2869         {
2870           if (! debug_write_name (info, fns, fhandle, n))
2871             return FALSE;
2872         }
2873     }
2874
2875   for (b = block->children; b != NULL; b = b->next)
2876     {
2877       if (! debug_write_block (info, fns, fhandle, b))
2878         return FALSE;
2879     }
2880
2881   if (! debug_write_linenos (info, fns, fhandle, block->end))
2882     return FALSE;
2883
2884   if (block->locals != NULL || block->parent == NULL)
2885     {
2886       if (! (*fns->end_block) (fhandle, block->end))
2887         return FALSE;
2888     }
2889
2890   return TRUE;
2891 }
2892
2893 /* Write out line number information up to ADDRESS.  */
2894
2895 static bfd_boolean
2896 debug_write_linenos (struct debug_handle *info,
2897                      const struct debug_write_fns *fns, void *fhandle,
2898                      bfd_vma address)
2899 {
2900   while (info->current_write_lineno != NULL)
2901     {
2902       struct debug_lineno *l;
2903
2904       l = info->current_write_lineno;
2905
2906       while (info->current_write_lineno_index < DEBUG_LINENO_COUNT)
2907         {
2908           if (l->linenos[info->current_write_lineno_index]
2909               == (unsigned long) -1)
2910             break;
2911
2912           if (l->addrs[info->current_write_lineno_index] >= address)
2913             return TRUE;
2914
2915           if (! (*fns->lineno) (fhandle, l->file->filename,
2916                                 l->linenos[info->current_write_lineno_index],
2917                                 l->addrs[info->current_write_lineno_index]))
2918             return FALSE;
2919
2920           ++info->current_write_lineno_index;
2921         }
2922
2923       info->current_write_lineno = l->next;
2924       info->current_write_lineno_index = 0;
2925     }
2926
2927   return TRUE;
2928 }
2929
2930 /* Get the ID number for a class.  If during the same call to
2931    debug_write we find a struct with the same definition with the same
2932    name, we use the same ID.  This type of things happens because the
2933    same struct will be defined by multiple compilation units.  */
2934
2935 static bfd_boolean
2936 debug_set_class_id (struct debug_handle *info, const char *tag,
2937                     struct debug_type_s *type)
2938 {
2939   struct debug_class_type *c;
2940   struct debug_class_id *l;
2941
2942   assert (type->kind == DEBUG_KIND_STRUCT
2943           || type->kind == DEBUG_KIND_UNION
2944           || type->kind == DEBUG_KIND_CLASS
2945           || type->kind == DEBUG_KIND_UNION_CLASS);
2946
2947   c = type->u.kclass;
2948
2949   if (c->id > info->base_id)
2950     return TRUE;
2951
2952   for (l = info->id_list; l != NULL; l = l->next)
2953     {
2954       if (l->type->kind != type->kind)
2955         continue;
2956
2957       if (tag == NULL)
2958         {
2959           if (l->tag != NULL)
2960             continue;
2961         }
2962       else
2963         {
2964           if (l->tag == NULL
2965               || l->tag[0] != tag[0]
2966               || strcmp (l->tag, tag) != 0)
2967             continue;
2968         }
2969
2970       if (debug_type_samep (info, l->type, type))
2971         {
2972           c->id = l->type->u.kclass->id;
2973           return TRUE;
2974         }
2975     }
2976
2977   /* There are no identical types.  Use a new ID, and add it to the
2978      list.  */
2979   ++info->class_id;
2980   c->id = info->class_id;
2981
2982   l = (struct debug_class_id *) xmalloc (sizeof *l);
2983   memset (l, 0, sizeof *l);
2984
2985   l->type = type;
2986   l->tag = tag;
2987
2988   l->next = info->id_list;
2989   info->id_list = l;
2990
2991   return TRUE;
2992 }
2993
2994 /* See if two types are the same.  At this point, we don't care about
2995    tags and the like.  */
2996
2997 static bfd_boolean
2998 debug_type_samep (struct debug_handle *info, struct debug_type_s *t1,
2999                   struct debug_type_s *t2)
3000 {
3001   struct debug_type_compare_list *l;
3002   struct debug_type_compare_list top;
3003   bfd_boolean ret;
3004
3005   if (t1 == NULL)
3006     return t2 == NULL;
3007   if (t2 == NULL)
3008     return FALSE;
3009
3010   while (t1->kind == DEBUG_KIND_INDIRECT)
3011     {
3012       t1 = *t1->u.kindirect->slot;
3013       if (t1 == NULL)
3014         return FALSE;
3015     }
3016   while (t2->kind == DEBUG_KIND_INDIRECT)
3017     {
3018       t2 = *t2->u.kindirect->slot;
3019       if (t2 == NULL)
3020         return FALSE;
3021     }
3022
3023   if (t1 == t2)
3024     return TRUE;
3025
3026   /* As a special case, permit a typedef to match a tag, since C++
3027      debugging output will sometimes add a typedef where C debugging
3028      output will not.  */
3029   if (t1->kind == DEBUG_KIND_NAMED
3030       && t2->kind == DEBUG_KIND_TAGGED)
3031     return debug_type_samep (info, t1->u.knamed->type, t2);
3032   else if (t1->kind == DEBUG_KIND_TAGGED
3033            && t2->kind == DEBUG_KIND_NAMED)
3034     return debug_type_samep (info, t1, t2->u.knamed->type);
3035
3036   if (t1->kind != t2->kind
3037       || t1->size != t2->size)
3038     return FALSE;
3039
3040   /* Get rid of the trivial cases first.  */
3041   switch (t1->kind)
3042     {
3043     default:
3044       break;
3045     case DEBUG_KIND_VOID:
3046     case DEBUG_KIND_FLOAT:
3047     case DEBUG_KIND_COMPLEX:
3048     case DEBUG_KIND_BOOL:
3049       return TRUE;
3050     case DEBUG_KIND_INT:
3051       return t1->u.kint == t2->u.kint;
3052     }
3053
3054   /* We have to avoid an infinite recursion.  We do this by keeping a
3055      list of types which we are comparing.  We just keep the list on
3056      the stack.  If we encounter a pair of types we are currently
3057      comparing, we just assume that they are equal.  */
3058   for (l = info->compare_list; l != NULL; l = l->next)
3059     {
3060       if (l->t1 == t1 && l->t2 == t2)
3061         return TRUE;
3062     }
3063
3064   top.t1 = t1;
3065   top.t2 = t2;
3066   top.next = info->compare_list;
3067   info->compare_list = &top;
3068
3069   switch (t1->kind)
3070     {
3071     default:
3072       abort ();
3073       ret = FALSE;
3074       break;
3075
3076     case DEBUG_KIND_STRUCT:
3077     case DEBUG_KIND_UNION:
3078     case DEBUG_KIND_CLASS:
3079     case DEBUG_KIND_UNION_CLASS:
3080       if (t1->u.kclass == NULL)
3081         ret = t2->u.kclass == NULL;
3082       else if (t2->u.kclass == NULL)
3083         ret = FALSE;
3084       else if (t1->u.kclass->id > info->base_id
3085                && t1->u.kclass->id == t2->u.kclass->id)
3086         ret = TRUE;
3087       else
3088         ret = debug_class_type_samep (info, t1, t2);
3089       break;
3090
3091     case DEBUG_KIND_ENUM:
3092       if (t1->u.kenum == NULL)
3093         ret = t2->u.kenum == NULL;
3094       else if (t2->u.kenum == NULL)
3095         ret = FALSE;
3096       else
3097         {
3098           const char **pn1, **pn2;
3099           bfd_signed_vma *pv1, *pv2;
3100
3101           pn1 = t1->u.kenum->names;
3102           pn2 = t2->u.kenum->names;
3103           pv1 = t1->u.kenum->values;
3104           pv2 = t2->u.kenum->values;
3105           while (*pn1 != NULL && *pn2 != NULL)
3106             {
3107               if (**pn1 != **pn2
3108                   || *pv1 != *pv2
3109                   || strcmp (*pn1, *pn2) != 0)
3110                 break;
3111               ++pn1;
3112               ++pn2;
3113               ++pv1;
3114               ++pv2;
3115             }
3116           ret = *pn1 == NULL && *pn2 == NULL;
3117         }
3118       break;
3119
3120     case DEBUG_KIND_POINTER:
3121       ret = debug_type_samep (info, t1->u.kpointer, t2->u.kpointer);
3122       break;
3123
3124     case DEBUG_KIND_FUNCTION:
3125       if (t1->u.kfunction->varargs != t2->u.kfunction->varargs
3126           || ! debug_type_samep (info, t1->u.kfunction->return_type,
3127                                  t2->u.kfunction->return_type)
3128           || ((t1->u.kfunction->arg_types == NULL)
3129               != (t2->u.kfunction->arg_types == NULL)))
3130         ret = FALSE;
3131       else if (t1->u.kfunction->arg_types == NULL)
3132         ret = TRUE;
3133       else
3134         {
3135           struct debug_type_s **a1, **a2;
3136
3137           a1 = t1->u.kfunction->arg_types;
3138           a2 = t2->u.kfunction->arg_types;
3139           while (*a1 != NULL && *a2 != NULL)
3140             {
3141               if (! debug_type_samep (info, *a1, *a2))
3142                 break;
3143               ++a1;
3144               ++a2;
3145             }
3146           ret = *a1 == NULL && *a2 == NULL;
3147         }
3148       break;
3149
3150     case DEBUG_KIND_REFERENCE:
3151       ret = debug_type_samep (info, t1->u.kreference, t2->u.kreference);
3152       break;
3153
3154     case DEBUG_KIND_RANGE:
3155       ret = (t1->u.krange->lower == t2->u.krange->lower
3156              && t1->u.krange->upper == t2->u.krange->upper
3157              && debug_type_samep (info, t1->u.krange->type,
3158                                   t2->u.krange->type));
3159
3160     case DEBUG_KIND_ARRAY:
3161       ret = (t1->u.karray->lower == t2->u.karray->lower
3162              && t1->u.karray->upper == t2->u.karray->upper
3163              && t1->u.karray->stringp == t2->u.karray->stringp
3164              && debug_type_samep (info, t1->u.karray->element_type,
3165                                   t2->u.karray->element_type));
3166       break;
3167
3168     case DEBUG_KIND_SET:
3169       ret = (t1->u.kset->bitstringp == t2->u.kset->bitstringp
3170              && debug_type_samep (info, t1->u.kset->type, t2->u.kset->type));
3171       break;
3172
3173     case DEBUG_KIND_OFFSET:
3174       ret = (debug_type_samep (info, t1->u.koffset->base_type,
3175                                t2->u.koffset->base_type)
3176              && debug_type_samep (info, t1->u.koffset->target_type,
3177                                   t2->u.koffset->target_type));
3178       break;
3179
3180     case DEBUG_KIND_METHOD:
3181       if (t1->u.kmethod->varargs != t2->u.kmethod->varargs
3182           || ! debug_type_samep (info, t1->u.kmethod->return_type,
3183                                  t2->u.kmethod->return_type)
3184           || ! debug_type_samep (info, t1->u.kmethod->domain_type,
3185                                  t2->u.kmethod->domain_type)
3186           || ((t1->u.kmethod->arg_types == NULL)
3187               != (t2->u.kmethod->arg_types == NULL)))
3188         ret = FALSE;
3189       else if (t1->u.kmethod->arg_types == NULL)
3190         ret = TRUE;
3191       else
3192         {
3193           struct debug_type_s **a1, **a2;
3194
3195           a1 = t1->u.kmethod->arg_types;
3196           a2 = t2->u.kmethod->arg_types;
3197           while (*a1 != NULL && *a2 != NULL)
3198             {
3199               if (! debug_type_samep (info, *a1, *a2))
3200                 break;
3201               ++a1;
3202               ++a2;
3203             }
3204           ret = *a1 == NULL && *a2 == NULL;
3205         }
3206       break;
3207
3208     case DEBUG_KIND_CONST:
3209       ret = debug_type_samep (info, t1->u.kconst, t2->u.kconst);
3210       break;
3211
3212     case DEBUG_KIND_VOLATILE:
3213       ret = debug_type_samep (info, t1->u.kvolatile, t2->u.kvolatile);
3214       break;
3215
3216     case DEBUG_KIND_NAMED:
3217     case DEBUG_KIND_TAGGED:
3218       ret = (strcmp (t1->u.knamed->name->name, t2->u.knamed->name->name) == 0
3219              && debug_type_samep (info, t1->u.knamed->type,
3220                                   t2->u.knamed->type));
3221       break;
3222     }
3223
3224   info->compare_list = top.next;
3225
3226   return ret;
3227 }
3228
3229 /* See if two classes are the same.  This is a subroutine of
3230    debug_type_samep.  */
3231
3232 static bfd_boolean
3233 debug_class_type_samep (struct debug_handle *info, struct debug_type_s *t1,
3234                         struct debug_type_s *t2)
3235 {
3236   struct debug_class_type *c1, *c2;
3237
3238   c1 = t1->u.kclass;
3239   c2 = t2->u.kclass;
3240
3241   if ((c1->fields == NULL) != (c2->fields == NULL)
3242       || (c1->baseclasses == NULL) != (c2->baseclasses == NULL)
3243       || (c1->methods == NULL) != (c2->methods == NULL)
3244       || (c1->vptrbase == NULL) != (c2->vptrbase == NULL))
3245     return FALSE;
3246
3247   if (c1->fields != NULL)
3248     {
3249       struct debug_field_s **pf1, **pf2;
3250
3251       for (pf1 = c1->fields, pf2 = c2->fields;
3252            *pf1 != NULL && *pf2 != NULL;
3253            pf1++, pf2++)
3254         {
3255           struct debug_field_s *f1, *f2;
3256
3257           f1 = *pf1;
3258           f2 = *pf2;
3259           if (f1->name[0] != f2->name[0]
3260               || f1->visibility != f2->visibility
3261               || f1->static_member != f2->static_member)
3262             return FALSE;
3263           if (f1->static_member)
3264             {
3265               if (strcmp (f1->u.s.physname, f2->u.s.physname) != 0)
3266                 return FALSE;
3267             }
3268           else
3269             {
3270               if (f1->u.f.bitpos != f2->u.f.bitpos
3271                   || f1->u.f.bitsize != f2->u.f.bitsize)
3272                 return FALSE;
3273             }
3274           /* We do the checks which require function calls last.  We
3275              don't require that the types of fields have the same
3276              names, since that sometimes fails in the presence of
3277              typedefs and we really don't care.  */
3278           if (strcmp (f1->name, f2->name) != 0
3279               || ! debug_type_samep (info,
3280                                      debug_get_real_type ((void *) info,
3281                                                           f1->type, NULL),
3282                                      debug_get_real_type ((void *) info,
3283                                                           f2->type, NULL)))
3284             return FALSE;
3285         }
3286       if (*pf1 != NULL || *pf2 != NULL)
3287         return FALSE;
3288     }
3289
3290   if (c1->vptrbase != NULL)
3291     {
3292       if (! debug_type_samep (info, c1->vptrbase, c2->vptrbase))
3293         return FALSE;
3294     }
3295
3296   if (c1->baseclasses != NULL)
3297     {
3298       struct debug_baseclass_s **pb1, **pb2;
3299
3300       for (pb1 = c1->baseclasses, pb2 = c2->baseclasses;
3301            *pb1 != NULL && *pb2 != NULL;
3302            ++pb1, ++pb2)
3303         {
3304           struct debug_baseclass_s *b1, *b2;
3305
3306           b1 = *pb1;
3307           b2 = *pb2;
3308           if (b1->bitpos != b2->bitpos
3309               || b1->is_virtual != b2->is_virtual
3310               || b1->visibility != b2->visibility
3311               || ! debug_type_samep (info, b1->type, b2->type))
3312             return FALSE;
3313         }
3314       if (*pb1 != NULL || *pb2 != NULL)
3315         return FALSE;
3316     }
3317
3318   if (c1->methods != NULL)
3319     {
3320       struct debug_method_s **pm1, **pm2;
3321
3322       for (pm1 = c1->methods, pm2 = c2->methods;
3323            *pm1 != NULL && *pm2 != NULL;
3324            ++pm1, ++pm2)
3325         {
3326           struct debug_method_s *m1, *m2;
3327
3328           m1 = *pm1;
3329           m2 = *pm2;
3330           if (m1->name[0] != m2->name[0]
3331               || strcmp (m1->name, m2->name) != 0
3332               || (m1->variants == NULL) != (m2->variants == NULL))
3333             return FALSE;
3334           if (m1->variants == NULL)
3335             {
3336               struct debug_method_variant_s **pv1, **pv2;
3337
3338               for (pv1 = m1->variants, pv2 = m2->variants;
3339                    *pv1 != NULL && *pv2 != NULL;
3340                    ++pv1, ++pv2)
3341                 {
3342                   struct debug_method_variant_s *v1, *v2;
3343
3344                   v1 = *pv1;
3345                   v2 = *pv2;
3346                   if (v1->physname[0] != v2->physname[0]
3347                       || v1->visibility != v2->visibility
3348                       || v1->constp != v2->constp
3349                       || v1->volatilep != v2->volatilep
3350                       || v1->voffset != v2->voffset
3351                       || (v1->context == NULL) != (v2->context == NULL)
3352                       || strcmp (v1->physname, v2->physname) != 0
3353                       || ! debug_type_samep (info, v1->type, v2->type))
3354                     return FALSE;
3355                   if (v1->context != NULL)
3356                     {
3357                       if (! debug_type_samep (info, v1->context,
3358                                               v2->context))
3359                         return FALSE;
3360                     }
3361                 }
3362               if (*pv1 != NULL || *pv2 != NULL)
3363                 return FALSE;
3364             }
3365         }
3366       if (*pm1 != NULL || *pm2 != NULL)
3367         return FALSE;
3368     }
3369
3370   return TRUE;
3371 }