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