OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [binutils/] [debug.c] - Blame information for rev 160

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.