binutils/debug.c

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