binutils/debug.c

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