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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [dbxout.c] - Blame information for rev 859

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

Line No. Rev Author Line
1 280 jeremybenn
/* Output dbx-format symbol table information from GNU compiler.
2
   Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4
   Free Software Foundation, Inc.
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify it under
9
the terms of the GNU General Public License as published by the Free
10
Software Foundation; either version 3, or (at your option) any later
11
version.
12
 
13
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14
WARRANTY; without even the implied warranty of MERCHANTABILITY or
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16
for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
 
23
/* Output dbx-format symbol table data.
24
   This consists of many symbol table entries, each of them
25
   a .stabs assembler pseudo-op with four operands:
26
   a "name" which is really a description of one symbol and its type,
27
   a "code", which is a symbol defined in stab.h whose name starts with N_,
28
   an unused operand always 0,
29
   and a "value" which is an address or an offset.
30
   The name is enclosed in doublequote characters.
31
 
32
   Each function, variable, typedef, and structure tag
33
   has a symbol table entry to define it.
34
   The beginning and end of each level of name scoping within
35
   a function are also marked by special symbol table entries.
36
 
37
   The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
38
   and a data type number.  The data type number may be followed by
39
   "=" and a type definition; normally this will happen the first time
40
   the type number is mentioned.  The type definition may refer to
41
   other types by number, and those type numbers may be followed
42
   by "=" and nested definitions.
43
 
44
   This can make the "name" quite long.
45
   When a name is more than 80 characters, we split the .stabs pseudo-op
46
   into two .stabs pseudo-ops, both sharing the same "code" and "value".
47
   The first one is marked as continued with a double-backslash at the
48
   end of its "name".
49
 
50
   The kind-of-symbol letter distinguished function names from global
51
   variables from file-scope variables from parameters from auto
52
   variables in memory from typedef names from register variables.
53
   See `dbxout_symbol'.
54
 
55
   The "code" is mostly redundant with the kind-of-symbol letter
56
   that goes in the "name", but not entirely: for symbols located
57
   in static storage, the "code" says which segment the address is in,
58
   which controls how it is relocated.
59
 
60
   The "value" for a symbol in static storage
61
   is the core address of the symbol (actually, the assembler
62
   label for the symbol).  For a symbol located in a stack slot
63
   it is the stack offset; for one in a register, the register number.
64
   For a typedef symbol, it is zero.
65
 
66
   If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67
   output while in the text section.
68
 
69
   For more on data type definitions, see `dbxout_type'.  */
70
 
71
#include "config.h"
72
#include "system.h"
73
#include "coretypes.h"
74
#include "tm.h"
75
 
76
#include "tree.h"
77
#include "rtl.h"
78
#include "flags.h"
79
#include "regs.h"
80
#include "insn-config.h"
81
#include "reload.h"
82
#include "output.h"
83
#include "dbxout.h"
84
#include "toplev.h"
85
#include "tm_p.h"
86
#include "ggc.h"
87
#include "debug.h"
88
#include "function.h"
89
#include "target.h"
90
#include "langhooks.h"
91
#include "obstack.h"
92
#include "expr.h"
93
 
94
#ifdef XCOFF_DEBUGGING_INFO
95
#include "xcoffout.h"
96
#endif
97
 
98
#define DBXOUT_DECR_NESTING \
99
  if (--debug_nesting == 0 && symbol_queue_index > 0) \
100
    { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
101
 
102
#define DBXOUT_DECR_NESTING_AND_RETURN(x) \
103
  do {--debug_nesting; return (x);} while (0)
104
 
105
#ifndef ASM_STABS_OP
106
# ifdef XCOFF_DEBUGGING_INFO
107
#  define ASM_STABS_OP "\t.stabx\t"
108
# else
109
#  define ASM_STABS_OP "\t.stabs\t"
110
# endif
111
#endif
112
 
113
#ifndef ASM_STABN_OP
114
#define ASM_STABN_OP "\t.stabn\t"
115
#endif
116
 
117
#ifndef ASM_STABD_OP
118
#define ASM_STABD_OP "\t.stabd\t"
119
#endif
120
 
121
#ifndef DBX_TYPE_DECL_STABS_CODE
122
#define DBX_TYPE_DECL_STABS_CODE N_LSYM
123
#endif
124
 
125
#ifndef DBX_STATIC_CONST_VAR_CODE
126
#define DBX_STATIC_CONST_VAR_CODE N_FUN
127
#endif
128
 
129
#ifndef DBX_REGPARM_STABS_CODE
130
#define DBX_REGPARM_STABS_CODE N_RSYM
131
#endif
132
 
133
#ifndef DBX_REGPARM_STABS_LETTER
134
#define DBX_REGPARM_STABS_LETTER 'P'
135
#endif
136
 
137
#ifndef NO_DBX_FUNCTION_END
138
#define NO_DBX_FUNCTION_END 0
139
#endif
140
 
141
#ifndef NO_DBX_BNSYM_ENSYM
142
#define NO_DBX_BNSYM_ENSYM 0
143
#endif
144
 
145
#ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
146
#define NO_DBX_MAIN_SOURCE_DIRECTORY 0
147
#endif
148
 
149
#ifndef DBX_BLOCKS_FUNCTION_RELATIVE
150
#define DBX_BLOCKS_FUNCTION_RELATIVE 0
151
#endif
152
 
153
#ifndef DBX_LINES_FUNCTION_RELATIVE
154
#define DBX_LINES_FUNCTION_RELATIVE 0
155
#endif
156
 
157
#ifndef DBX_CONTIN_LENGTH
158
#define DBX_CONTIN_LENGTH 80
159
#endif
160
 
161
#ifndef DBX_CONTIN_CHAR
162
#define DBX_CONTIN_CHAR '\\'
163
#endif
164
 
165
enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
166
 
167
/* Structure recording information about a C data type.
168
   The status element says whether we have yet output
169
   the definition of the type.  TYPE_XREF says we have
170
   output it as a cross-reference only.
171
   The file_number and type_number elements are used if DBX_USE_BINCL
172
   is defined.  */
173
 
174
struct GTY(()) typeinfo {
175
  enum typestatus status;
176
  int file_number;
177
  int type_number;
178
};
179
 
180
/* Vector recording information about C data types.
181
   When we first notice a data type (a tree node),
182
   we assign it a number using next_type_number.
183
   That is its index in this vector.  */
184
 
185
static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
186
 
187
/* Number of elements of space allocated in `typevec'.  */
188
 
189
static GTY(()) int typevec_len;
190
 
191
/* In dbx output, each type gets a unique number.
192
   This is the number for the next type output.
193
   The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field.  */
194
 
195
static GTY(()) int next_type_number;
196
 
197
/* The C front end may call dbxout_symbol before dbxout_init runs.
198
   We save all such decls in this list and output them when we get
199
   to dbxout_init.  */
200
 
201
static GTY(()) tree preinit_symbols;
202
 
203
enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
204
 
205
/* When using N_BINCL in dbx output, each type number is actually a
206
   pair of the file number and the type number within the file.
207
   This is a stack of input files.  */
208
 
209
struct dbx_file
210
{
211
  struct dbx_file *next;
212
  int file_number;
213
  int next_type_number;
214
  enum binclstatus bincl_status;  /* Keep track of lazy bincl.  */
215
  const char *pending_bincl_name; /* Name of bincl.  */
216
  struct dbx_file *prev;          /* Chain to traverse all pending bincls.  */
217
};
218
 
219
/* This is the top of the stack.
220
 
221
   This is not saved for PCH, because restoring a PCH should not change it.
222
   next_file_number does have to be saved, because the PCH may use some
223
   file numbers; however, just before restoring a PCH, next_file_number
224
   should always be 0 because we should not have needed any file numbers
225
   yet.  */
226
 
227
#if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
228
    && defined (DBX_USE_BINCL)
229
static struct dbx_file *current_file;
230
#endif
231
 
232
/* This is the next file number to use.  */
233
 
234
static GTY(()) int next_file_number;
235
 
236
/* A counter for dbxout_function_end.  */
237
 
238
static GTY(()) int scope_labelno;
239
 
240
/* A counter for dbxout_source_line.  */
241
 
242
static GTY(()) int dbxout_source_line_counter;
243
 
244
/* Number for the next N_SOL filename stabs label.  The number 0 is reserved
245
   for the N_SO filename stabs label.  */
246
 
247
static GTY(()) int source_label_number = 1;
248
 
249
/* Last source file name mentioned in a NOTE insn.  */
250
 
251
static GTY(()) const char *lastfile;
252
 
253
/* Used by PCH machinery to detect if 'lastfile' should be reset to
254
   base_input_file.  */
255
static GTY(()) int lastfile_is_base;
256
 
257
/* Typical USG systems don't have stab.h, and they also have
258
   no use for DBX-format debugging info.  */
259
 
260
#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
261
 
262
#ifdef DBX_USE_BINCL
263
/* If zero then there is no pending BINCL.  */
264
static int pending_bincls = 0;
265
#endif
266
 
267
/* The original input file name.  */
268
static const char *base_input_file;
269
 
270
#ifdef DEBUG_SYMS_TEXT
271
#define FORCE_TEXT switch_to_section (current_function_section ())
272
#else
273
#define FORCE_TEXT
274
#endif
275
 
276
#include "gstab.h"
277
 
278
/* 1 if PARM is passed to this function in memory.  */
279
 
280
#define PARM_PASSED_IN_MEMORY(PARM) \
281
 (MEM_P (DECL_INCOMING_RTL (PARM)))
282
 
283
/* A C expression for the integer offset value of an automatic variable
284
   (N_LSYM) having address X (an RTX).  */
285
#ifndef DEBUGGER_AUTO_OFFSET
286
#define DEBUGGER_AUTO_OFFSET(X) \
287
  (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
288
#endif
289
 
290
/* A C expression for the integer offset value of an argument (N_PSYM)
291
   having address X (an RTX).  The nominal offset is OFFSET.  */
292
#ifndef DEBUGGER_ARG_OFFSET
293
#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
294
#endif
295
 
296
/* This obstack holds the stab string currently being constructed.  We
297
   build it up here, then write it out, so we can split long lines up
298
   properly (see dbxout_finish_complex_stabs).  */
299
static struct obstack stabstr_ob;
300
static size_t stabstr_last_contin_point;
301
 
302
#ifdef DBX_USE_BINCL
303
static void emit_bincl_stab             (const char *c);
304
static void emit_pending_bincls         (void);
305
#endif
306
static inline void emit_pending_bincls_if_required (void);
307
 
308
static void dbxout_init (const char *);
309
 
310
static void dbxout_finish (const char *);
311
static void dbxout_start_source_file (unsigned, const char *);
312
static void dbxout_end_source_file (unsigned);
313
static void dbxout_typedefs (tree);
314
static void dbxout_type_index (tree);
315
static void dbxout_args (tree);
316
static void dbxout_type_fields (tree);
317
static void dbxout_type_method_1 (tree);
318
static void dbxout_type_methods (tree);
319
static void dbxout_range_type (tree, tree, tree);
320
static void dbxout_type (tree, int);
321
static bool print_int_cst_bounds_in_octal_p (tree, tree, tree);
322
static bool is_fortran (void);
323
static void dbxout_type_name (tree);
324
static void dbxout_class_name_qualifiers (tree);
325
static int dbxout_symbol_location (tree, tree, const char *, rtx);
326
static void dbxout_symbol_name (tree, const char *, int);
327
static void dbxout_common_name (tree, const char *, stab_code_type);
328
static const char *dbxout_common_check (tree, int *);
329
static void dbxout_global_decl (tree);
330
static void dbxout_type_decl (tree, int);
331
static void dbxout_handle_pch (unsigned);
332
 
333
/* The debug hooks structure.  */
334
#if defined (DBX_DEBUGGING_INFO)
335
 
336
static void dbxout_source_line (unsigned int, const char *, int, bool);
337
static void dbxout_begin_prologue (unsigned int, const char *);
338
static void dbxout_source_file (const char *);
339
static void dbxout_function_end (tree);
340
static void dbxout_begin_function (tree);
341
static void dbxout_begin_block (unsigned, unsigned);
342
static void dbxout_end_block (unsigned, unsigned);
343
static void dbxout_function_decl (tree);
344
 
345
const struct gcc_debug_hooks dbx_debug_hooks =
346
{
347
  dbxout_init,
348
  dbxout_finish,
349
  debug_nothing_void,
350
  debug_nothing_int_charstar,
351
  debug_nothing_int_charstar,
352
  dbxout_start_source_file,
353
  dbxout_end_source_file,
354
  dbxout_begin_block,
355
  dbxout_end_block,
356
  debug_true_const_tree,                 /* ignore_block */
357
  dbxout_source_line,                    /* source_line */
358
  dbxout_begin_prologue,                 /* begin_prologue */
359
  debug_nothing_int_charstar,            /* end_prologue */
360
  debug_nothing_int_charstar,            /* end_epilogue */
361
#ifdef DBX_FUNCTION_FIRST
362
  dbxout_begin_function,
363
#else
364
  debug_nothing_tree,                    /* begin_function */
365
#endif
366
  debug_nothing_int,                     /* end_function */
367
  dbxout_function_decl,
368
  dbxout_global_decl,                    /* global_decl */
369
  dbxout_type_decl,                      /* type_decl */
370
  debug_nothing_tree_tree_tree_bool,     /* imported_module_or_decl */
371
  debug_nothing_tree,                    /* deferred_inline_function */
372
  debug_nothing_tree,                    /* outlining_inline_function */
373
  debug_nothing_rtx,                     /* label */
374
  dbxout_handle_pch,                     /* handle_pch */
375
  debug_nothing_rtx,                     /* var_location */
376
  debug_nothing_void,                    /* switch_text_section */
377
  debug_nothing_tree,                    /* direct_call */
378
  debug_nothing_tree_int,                /* virtual_call_token */
379
  debug_nothing_rtx_rtx,                 /* copy_call_info */
380
  debug_nothing_uid,                     /* virtual_call */
381
  debug_nothing_tree_tree,               /* set_name */
382
 
383
};
384
#endif /* DBX_DEBUGGING_INFO  */
385
 
386
#if defined (XCOFF_DEBUGGING_INFO)
387
const struct gcc_debug_hooks xcoff_debug_hooks =
388
{
389
  dbxout_init,
390
  dbxout_finish,
391
  debug_nothing_void,
392
  debug_nothing_int_charstar,
393
  debug_nothing_int_charstar,
394
  dbxout_start_source_file,
395
  dbxout_end_source_file,
396
  xcoffout_begin_block,
397
  xcoffout_end_block,
398
  debug_true_const_tree,                 /* ignore_block */
399
  xcoffout_source_line,
400
  xcoffout_begin_prologue,               /* begin_prologue */
401
  debug_nothing_int_charstar,            /* end_prologue */
402
  xcoffout_end_epilogue,
403
  debug_nothing_tree,                    /* begin_function */
404
  xcoffout_end_function,
405
  debug_nothing_tree,                    /* function_decl */
406
  dbxout_global_decl,                    /* global_decl */
407
  dbxout_type_decl,                      /* type_decl */
408
  debug_nothing_tree_tree_tree_bool,     /* imported_module_or_decl */
409
  debug_nothing_tree,                    /* deferred_inline_function */
410
  debug_nothing_tree,                    /* outlining_inline_function */
411
  debug_nothing_rtx,                     /* label */
412
  dbxout_handle_pch,                     /* handle_pch */
413
  debug_nothing_rtx,                     /* var_location */
414
  debug_nothing_void,                    /* switch_text_section */
415
  debug_nothing_tree,                    /* direct_call */
416
  debug_nothing_tree_int,                /* virtual_call_token */
417
  debug_nothing_rtx_rtx,                 /* copy_call_info */
418
  debug_nothing_uid,                     /* virtual_call */
419
  debug_nothing_tree_tree,               /* set_name */
420
 
421
};
422
#endif /* XCOFF_DEBUGGING_INFO  */
423
 
424
/* Numeric formatting helper macro.  Note that this does not handle
425
   hexadecimal.  */
426
#define NUMBER_FMT_LOOP(P, NUM, BASE)           \
427
  do                                            \
428
    {                                           \
429
      int digit = NUM % BASE;                   \
430
      NUM /= BASE;                              \
431
      *--P = digit + '0';                       \
432
    }                                           \
433
  while (NUM > 0)
434
 
435
/* Utility: write a decimal integer NUM to asm_out_file.  */
436
void
437
dbxout_int (int num)
438
{
439
  char buf[64];
440
  char *p = buf + sizeof buf;
441
  unsigned int unum;
442
 
443
  if (num == 0)
444
    {
445
      putc ('0', asm_out_file);
446
      return;
447
    }
448
  if (num < 0)
449
    {
450
      putc ('-', asm_out_file);
451
      unum = -num;
452
    }
453
  else
454
    unum = num;
455
 
456
  NUMBER_FMT_LOOP (p, unum, 10);
457
 
458
  while (p < buf + sizeof buf)
459
    {
460
      putc (*p, asm_out_file);
461
      p++;
462
    }
463
}
464
 
465
 
466
/* Primitives for emitting simple stabs directives.  All other stabs
467
   routines should use these functions instead of directly emitting
468
   stabs.  They are exported because machine-dependent code may need
469
   to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
470
   forwards to code in CPU.c.  */
471
 
472
/* The following functions should all be called immediately after one
473
   of the dbxout_begin_stab* functions (below).  They write out
474
   various things as the value of a stab.  */
475
 
476
/* Write out a literal zero as the value of a stab.  */
477
void
478
dbxout_stab_value_zero (void)
479
{
480
  fputs ("0\n", asm_out_file);
481
}
482
 
483
/* Write out the label LABEL as the value of a stab.  */
484
void
485
dbxout_stab_value_label (const char *label)
486
{
487
  assemble_name (asm_out_file, label);
488
  putc ('\n', asm_out_file);
489
}
490
 
491
/* Write out the difference of two labels, LABEL - BASE, as the value
492
   of a stab.  */
493
void
494
dbxout_stab_value_label_diff (const char *label, const char *base)
495
{
496
  assemble_name (asm_out_file, label);
497
  putc ('-', asm_out_file);
498
  assemble_name (asm_out_file, base);
499
  putc ('\n', asm_out_file);
500
}
501
 
502
/* Write out an internal label as the value of a stab, and immediately
503
   emit that internal label.  This should be used only when
504
   dbxout_stabd will not work.  STEM is the name stem of the label,
505
   COUNTERP is a pointer to a counter variable which will be used to
506
   guarantee label uniqueness.  */
507
void
508
dbxout_stab_value_internal_label (const char *stem, int *counterp)
509
{
510
  char label[100];
511
  int counter = counterp ? (*counterp)++ : 0;
512
 
513
  ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
514
  dbxout_stab_value_label (label);
515
  targetm.asm_out.internal_label (asm_out_file, stem, counter);
516
}
517
 
518
/* Write out the difference between BASE and an internal label as the
519
   value of a stab, and immediately emit that internal label.  STEM and
520
   COUNTERP are as for dbxout_stab_value_internal_label.  */
521
void
522
dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
523
                                       const char *base)
524
{
525
  char label[100];
526
  int counter = counterp ? (*counterp)++ : 0;
527
 
528
  ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
529
  dbxout_stab_value_label_diff (label, base);
530
  targetm.asm_out.internal_label (asm_out_file, stem, counter);
531
}
532
 
533
/* The following functions produce specific kinds of stab directives.  */
534
 
535
/* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file.  */
536
void
537
dbxout_stabd (int stype, int sdesc)
538
{
539
  fputs (ASM_STABD_OP, asm_out_file);
540
  dbxout_int (stype);
541
  fputs (",0,", asm_out_file);
542
  dbxout_int (sdesc);
543
  putc ('\n', asm_out_file);
544
}
545
 
546
/* Write a .stabn directive with type STYPE.  This function stops
547
   short of emitting the value field, which is the responsibility of
548
   the caller (normally it will be either a symbol or the difference
549
   of two symbols).  */
550
 
551
void
552
dbxout_begin_stabn (int stype)
553
{
554
  fputs (ASM_STABN_OP, asm_out_file);
555
  dbxout_int (stype);
556
  fputs (",0,0,", asm_out_file);
557
}
558
 
559
/* Write a .stabn directive with type N_SLINE and desc LINE.  As above,
560
   the value field is the responsibility of the caller.  */
561
void
562
dbxout_begin_stabn_sline (int lineno)
563
{
564
  fputs (ASM_STABN_OP, asm_out_file);
565
  dbxout_int (N_SLINE);
566
  fputs (",0,", asm_out_file);
567
  dbxout_int (lineno);
568
  putc (',', asm_out_file);
569
}
570
 
571
/* Begin a .stabs directive with string "", type STYPE, and desc and
572
   other fields 0.  The value field is the responsibility of the
573
   caller.  This function cannot be used for .stabx directives.  */
574
void
575
dbxout_begin_empty_stabs (int stype)
576
{
577
  fputs (ASM_STABS_OP, asm_out_file);
578
  fputs ("\"\",", asm_out_file);
579
  dbxout_int (stype);
580
  fputs (",0,0,", asm_out_file);
581
}
582
 
583
/* Begin a .stabs directive with string STR, type STYPE, and desc 0.
584
   The value field is the responsibility of the caller.  */
585
void
586
dbxout_begin_simple_stabs (const char *str, int stype)
587
{
588
  fputs (ASM_STABS_OP, asm_out_file);
589
  output_quoted_string (asm_out_file, str);
590
  putc (',', asm_out_file);
591
  dbxout_int (stype);
592
  fputs (",0,0,", asm_out_file);
593
}
594
 
595
/* As above but use SDESC for the desc field.  */
596
void
597
dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
598
{
599
  fputs (ASM_STABS_OP, asm_out_file);
600
  output_quoted_string (asm_out_file, str);
601
  putc (',', asm_out_file);
602
  dbxout_int (stype);
603
  fputs (",0,", asm_out_file);
604
  dbxout_int (sdesc);
605
  putc (',', asm_out_file);
606
}
607
 
608
/* The next set of functions are entirely concerned with production of
609
   "complex" .stabs directives: that is, .stabs directives whose
610
   strings have to be constructed piecemeal.  dbxout_type,
611
   dbxout_symbol, etc. use these routines heavily.  The string is queued
612
   up in an obstack, then written out by dbxout_finish_complex_stabs, which
613
   is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
614
   (You might think it would be more efficient to go straight to stdio
615
   when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
616
   out not to be the case, and anyway this needs fewer #ifdefs.)  */
617
 
618
/* Begin a complex .stabs directive.  If we can, write the initial
619
   ASM_STABS_OP to the asm_out_file.  */
620
 
621
static void
622
dbxout_begin_complex_stabs (void)
623
{
624
  emit_pending_bincls_if_required ();
625
  FORCE_TEXT;
626
  fputs (ASM_STABS_OP, asm_out_file);
627
  putc ('"', asm_out_file);
628
  gcc_assert (stabstr_last_contin_point == 0);
629
}
630
 
631
/* As above, but do not force text or emit pending bincls.  This is
632
   used by dbxout_symbol_location, which needs to do something else.  */
633
static void
634
dbxout_begin_complex_stabs_noforcetext (void)
635
{
636
  fputs (ASM_STABS_OP, asm_out_file);
637
  putc ('"', asm_out_file);
638
  gcc_assert (stabstr_last_contin_point == 0);
639
}
640
 
641
/* Add CHR, a single character, to the string being built.  */
642
#define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
643
 
644
/* Add STR, a normal C string, to the string being built.  */
645
#define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
646
 
647
/* Add the text of ID, an IDENTIFIER_NODE, to the string being built.  */
648
#define stabstr_I(id) obstack_grow (&stabstr_ob, \
649
                                    IDENTIFIER_POINTER (id), \
650
                                    IDENTIFIER_LENGTH (id))
651
 
652
/* Add NUM, a signed decimal number, to the string being built.  */
653
static void
654
stabstr_D (HOST_WIDE_INT num)
655
{
656
  char buf[64];
657
  char *p = buf + sizeof buf;
658
  unsigned int unum;
659
 
660
  if (num == 0)
661
    {
662
      stabstr_C ('0');
663
      return;
664
    }
665
  if (num < 0)
666
    {
667
      stabstr_C ('-');
668
      unum = -num;
669
    }
670
  else
671
    unum = num;
672
 
673
  NUMBER_FMT_LOOP (p, unum, 10);
674
 
675
  obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
676
}
677
 
678
/* Add NUM, an unsigned decimal number, to the string being built.  */
679
static void
680
stabstr_U (unsigned HOST_WIDE_INT num)
681
{
682
  char buf[64];
683
  char *p = buf + sizeof buf;
684
  if (num == 0)
685
    {
686
      stabstr_C ('0');
687
      return;
688
    }
689
  NUMBER_FMT_LOOP (p, num, 10);
690
  obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
691
}
692
 
693
/* Add CST, an INTEGER_CST tree, to the string being built as an
694
   unsigned octal number.  This routine handles values which are
695
   larger than a single HOST_WIDE_INT.  */
696
static void
697
stabstr_O (tree cst)
698
{
699
  unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (cst);
700
  unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
701
 
702
  char buf[128];
703
  char *p = buf + sizeof buf;
704
 
705
  /* GDB wants constants with no extra leading "1" bits, so
706
     we need to remove any sign-extension that might be
707
     present.  */
708
  {
709
    const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst));
710
    if (width == HOST_BITS_PER_WIDE_INT * 2)
711
      ;
712
    else if (width > HOST_BITS_PER_WIDE_INT)
713
      high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
714
    else if (width == HOST_BITS_PER_WIDE_INT)
715
      high = 0;
716
    else
717
      high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
718
  }
719
 
720
  /* Leading zero for base indicator.  */
721
  stabstr_C ('0');
722
 
723
  /* If the value is zero, the base indicator will serve as the value
724
     all by itself.  */
725
  if (high == 0 && low == 0)
726
    return;
727
 
728
  /* If the high half is zero, we need only print the low half normally.  */
729
  if (high == 0)
730
    NUMBER_FMT_LOOP (p, low, 8);
731
  else
732
    {
733
      /* When high != 0, we need to print enough zeroes from low to
734
         give the digits from high their proper place-values.  Hence
735
         NUMBER_FMT_LOOP cannot be used.  */
736
      const int n_digits = HOST_BITS_PER_WIDE_INT / 3;
737
      int i;
738
 
739
      for (i = 1; i <= n_digits; i++)
740
        {
741
          unsigned int digit = low % 8;
742
          low /= 8;
743
          *--p = '0' + digit;
744
        }
745
 
746
      /* Octal digits carry exactly three bits of information.  The
747
         width of a HOST_WIDE_INT is not normally a multiple of three.
748
         Therefore, the next digit printed probably needs to carry
749
         information from both low and high.  */
750
      if (HOST_BITS_PER_WIDE_INT % 3 != 0)
751
        {
752
          const int n_leftover_bits = HOST_BITS_PER_WIDE_INT % 3;
753
          const int n_bits_from_high = 3 - n_leftover_bits;
754
 
755
          const unsigned HOST_WIDE_INT
756
            low_mask = (((unsigned HOST_WIDE_INT)1) << n_leftover_bits) - 1;
757
          const unsigned HOST_WIDE_INT
758
            high_mask = (((unsigned HOST_WIDE_INT)1) << n_bits_from_high) - 1;
759
 
760
          unsigned int digit;
761
 
762
          /* At this point, only the bottom n_leftover_bits bits of low
763
             should be set.  */
764
          gcc_assert (!(low & ~low_mask));
765
 
766
          digit = (low | ((high & high_mask) << n_leftover_bits));
767
          high >>= n_bits_from_high;
768
 
769
          *--p = '0' + digit;
770
        }
771
 
772
      /* Now we can format high in the normal manner.  However, if
773
         the only bits of high that were set were handled by the
774
         digit split between low and high, high will now be zero, and
775
         we don't want to print extra digits in that case.  */
776
      if (high)
777
        NUMBER_FMT_LOOP (p, high, 8);
778
    }
779
 
780
  obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
781
}
782
 
783
/* Called whenever it is safe to break a stabs string into multiple
784
   .stabs directives.  If the current string has exceeded the limit
785
   set by DBX_CONTIN_LENGTH, mark the current position in the buffer
786
   as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
787
   it is a backslash) and a null character.  */
788
static inline void
789
stabstr_continue (void)
790
{
791
  if (DBX_CONTIN_LENGTH > 0
792
      && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
793
         > DBX_CONTIN_LENGTH)
794
    {
795
      if (DBX_CONTIN_CHAR == '\\')
796
        obstack_1grow (&stabstr_ob, '\\');
797
      obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
798
      obstack_1grow (&stabstr_ob, '\0');
799
      stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
800
    }
801
}
802
#define CONTIN stabstr_continue ()
803
 
804
/* Macro subroutine of dbxout_finish_complex_stabs, which emits
805
   all of the arguments to the .stabs directive after the string.
806
   Overridden by xcoffout.h.  CODE is the stabs code for this symbol;
807
   LINE is the source line to write into the desc field (in extended
808
   mode); SYM is the symbol itself.
809
 
810
   ADDR, LABEL, and NUMBER are three different ways to represent the
811
   stabs value field.  At most one of these should be nonzero.
812
 
813
     ADDR is used most of the time; it represents the value as an
814
     RTL address constant.
815
 
816
     LABEL is used (currently) only for N_CATCH stabs; it represents
817
     the value as a string suitable for assemble_name.
818
 
819
     NUMBER is used when the value is an offset from an implicit base
820
     pointer (e.g. for a stack variable), or an index (e.g. for a
821
     register variable).  It represents the value as a decimal integer.  */
822
 
823
#ifndef DBX_FINISH_STABS
824
#define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER)  \
825
do {                                                            \
826
  int line_ = use_gnu_debug_info_extensions ? LINE : 0;          \
827
                                                                \
828
  dbxout_int (CODE);                                            \
829
  fputs (",0,", asm_out_file);                                  \
830
  dbxout_int (line_);                                           \
831
  putc (',', asm_out_file);                                     \
832
  if (ADDR)                                                     \
833
    output_addr_const (asm_out_file, ADDR);                     \
834
  else if (LABEL)                                               \
835
    assemble_name (asm_out_file, LABEL);                        \
836
  else                                                          \
837
    dbxout_int (NUMBER);                                        \
838
  putc ('\n', asm_out_file);                                    \
839
} while (0)
840
#endif
841
 
842
/* Finish the emission of a complex .stabs directive.  When DBX_CONTIN_LENGTH
843
   is zero, this has only to emit the close quote and the remainder of
844
   the arguments.  When it is nonzero, the string has been marshalled in
845
   stabstr_ob, and this routine is responsible for breaking it up into
846
   DBX_CONTIN_LENGTH-sized chunks.
847
 
848
   SYM is the DECL of the symbol under consideration; it is used only
849
   for its DECL_SOURCE_LINE.  The other arguments are all passed directly
850
   to DBX_FINISH_STABS; see above for details.  */
851
 
852
static void
853
dbxout_finish_complex_stabs (tree sym, stab_code_type code,
854
                             rtx addr, const char *label, int number)
855
{
856
  int line ATTRIBUTE_UNUSED;
857
  char *str;
858
  size_t len;
859
 
860
  line = sym ? DECL_SOURCE_LINE (sym) : 0;
861
  if (DBX_CONTIN_LENGTH > 0)
862
    {
863
      char *chunk;
864
      size_t chunklen;
865
 
866
      /* Nul-terminate the growing string, then get its size and
867
         address.  */
868
      obstack_1grow (&stabstr_ob, '\0');
869
 
870
      len = obstack_object_size (&stabstr_ob);
871
      chunk = str = XOBFINISH (&stabstr_ob, char *);
872
 
873
      /* Within the buffer are a sequence of NUL-separated strings,
874
         each of which is to be written out as a separate stab
875
         directive.  */
876
      for (;;)
877
        {
878
          chunklen = strlen (chunk);
879
          fwrite (chunk, 1, chunklen, asm_out_file);
880
          fputs ("\",", asm_out_file);
881
 
882
          /* Must add an extra byte to account for the NUL separator.  */
883
          chunk += chunklen + 1;
884
          len   -= chunklen + 1;
885
 
886
          /* Only put a line number on the last stab in the sequence.  */
887
          DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
888
                            addr, label, number);
889
          if (len == 0)
890
            break;
891
 
892
          fputs (ASM_STABS_OP, asm_out_file);
893
          putc ('"', asm_out_file);
894
        }
895
      stabstr_last_contin_point = 0;
896
    }
897
  else
898
    {
899
      /* No continuations - we can put the whole string out at once.
900
         It is faster to augment the string with the close quote and
901
         comma than to do a two-character fputs.  */
902
      obstack_grow (&stabstr_ob, "\",", 2);
903
      len = obstack_object_size (&stabstr_ob);
904
      str = XOBFINISH (&stabstr_ob, char *);
905
 
906
      fwrite (str, 1, len, asm_out_file);
907
      DBX_FINISH_STABS (sym, code, line, addr, label, number);
908
    }
909
  obstack_free (&stabstr_ob, str);
910
}
911
 
912
#if defined (DBX_DEBUGGING_INFO)
913
 
914
static void
915
dbxout_function_end (tree decl ATTRIBUTE_UNUSED)
916
{
917
  char lscope_label_name[100];
918
 
919
  /* The Lscope label must be emitted even if we aren't doing anything
920
     else; dbxout_block needs it.  */
921
  switch_to_section (function_section (current_function_decl));
922
 
923
  /* Convert Lscope into the appropriate format for local labels in case
924
     the system doesn't insert underscores in front of user generated
925
     labels.  */
926
  ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
927
  targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
928
 
929
  /* The N_FUN tag at the end of the function is a GNU extension,
930
     which may be undesirable, and is unnecessary if we do not have
931
     named sections.  */
932
  if (!use_gnu_debug_info_extensions
933
      || NO_DBX_FUNCTION_END
934
      || !targetm.have_named_sections)
935
    return;
936
 
937
  /* By convention, GCC will mark the end of a function with an N_FUN
938
     symbol and an empty string.  */
939
  if (flag_reorder_blocks_and_partition)
940
    {
941
      dbxout_begin_empty_stabs (N_FUN);
942
      dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
943
                                    crtl->subsections.hot_section_label);
944
      dbxout_begin_empty_stabs (N_FUN);
945
      dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
946
                                    crtl->subsections.cold_section_label);
947
    }
948
  else
949
    {
950
      char begin_label[20];
951
      /* Reference current function start using LFBB.  */
952
      ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
953
      dbxout_begin_empty_stabs (N_FUN);
954
      dbxout_stab_value_label_diff (lscope_label_name, begin_label);
955
    }
956
 
957
  if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
958
    dbxout_stabd (N_ENSYM, 0);
959
}
960
#endif /* DBX_DEBUGGING_INFO */
961
 
962
/* Get lang description for N_SO stab.  */
963
static unsigned int ATTRIBUTE_UNUSED
964
get_lang_number (void)
965
{
966
  const char *language_string = lang_hooks.name;
967
 
968
  if (strcmp (language_string, "GNU C") == 0)
969
    return N_SO_C;
970
  else if (strcmp (language_string, "GNU C++") == 0)
971
    return N_SO_CC;
972
  else if (strcmp (language_string, "GNU F77") == 0)
973
    return N_SO_FORTRAN;
974
  else if (strcmp (language_string, "GNU Fortran") == 0)
975
    return N_SO_FORTRAN90; /* CHECKME */
976
  else if (strcmp (language_string, "GNU Pascal") == 0)
977
    return N_SO_PASCAL;
978
  else if (strcmp (language_string, "GNU Objective-C") == 0)
979
    return N_SO_OBJC;
980
  else if (strcmp (language_string, "GNU Objective-C++") == 0)
981
    return N_SO_OBJCPLUS;
982
  else
983
    return 0;
984
 
985
}
986
 
987
static bool
988
is_fortran (void)
989
{
990
   unsigned int lang = get_lang_number ();
991
 
992
   return (lang == N_SO_FORTRAN) || (lang == N_SO_FORTRAN90);
993
}
994
 
995
/* At the beginning of compilation, start writing the symbol table.
996
   Initialize `typevec' and output the standard data types of C.  */
997
 
998
static void
999
dbxout_init (const char *input_file_name)
1000
{
1001
  char ltext_label_name[100];
1002
  bool used_ltext_label_name = false;
1003
  tree syms = lang_hooks.decls.getdecls ();
1004
  const char *mapped_name;
1005
 
1006
  typevec_len = 100;
1007
  typevec = GGC_CNEWVEC (struct typeinfo, typevec_len);
1008
 
1009
  /* stabstr_ob contains one string, which will be just fine with
1010
     1-byte alignment.  */
1011
  obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
1012
 
1013
  /* Convert Ltext into the appropriate format for local labels in case
1014
     the system doesn't insert underscores in front of user generated
1015
     labels.  */
1016
  ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
1017
 
1018
  /* Put the current working directory in an N_SO symbol.  */
1019
  if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
1020
    {
1021
      static const char *cwd;
1022
 
1023
      if (!cwd)
1024
        {
1025
          cwd = get_src_pwd ();
1026
          if (cwd[0] == '\0')
1027
            cwd = "/";
1028
          else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
1029
            cwd = concat (cwd, "/", NULL);
1030
          cwd = remap_debug_filename (cwd);
1031
        }
1032
#ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1033
      DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
1034
#else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1035
      dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
1036
      dbxout_stab_value_label (ltext_label_name);
1037
      used_ltext_label_name = true;
1038
#endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1039
    }
1040
 
1041
  mapped_name = remap_debug_filename (input_file_name);
1042
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1043
  DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
1044
#else
1045
  dbxout_begin_simple_stabs_desc (mapped_name, N_SO, get_lang_number ());
1046
  dbxout_stab_value_label (ltext_label_name);
1047
  used_ltext_label_name = true;
1048
#endif
1049
 
1050
  if (used_ltext_label_name)
1051
    {
1052
      switch_to_section (text_section);
1053
      targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
1054
    }
1055
 
1056
  /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1057
     The string used is historical.  */
1058
#ifndef NO_DBX_GCC_MARKER
1059
  dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
1060
  dbxout_stab_value_zero ();
1061
#endif
1062
 
1063
  base_input_file = lastfile = input_file_name;
1064
 
1065
  next_type_number = 1;
1066
 
1067
#ifdef DBX_USE_BINCL
1068
  current_file = XNEW (struct dbx_file);
1069
  current_file->next = NULL;
1070
  current_file->file_number = 0;
1071
  current_file->next_type_number = 1;
1072
  next_file_number = 1;
1073
  current_file->prev = NULL;
1074
  current_file->bincl_status = BINCL_NOT_REQUIRED;
1075
  current_file->pending_bincl_name = NULL;
1076
#endif
1077
 
1078
  /* Get all permanent types that have typedef names, and output them
1079
     all, except for those already output.  Some language front ends
1080
     put these declarations in the top-level scope; some do not;
1081
     the latter are responsible for calling debug_hooks->type_decl from
1082
     their record_builtin_type function.  */
1083
  dbxout_typedefs (syms);
1084
 
1085
  if (preinit_symbols)
1086
    {
1087
      tree t;
1088
      for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1089
        dbxout_symbol (TREE_VALUE (t), 0);
1090
      preinit_symbols = 0;
1091
    }
1092
}
1093
 
1094
/* Output any typedef names for types described by TYPE_DECLs in SYMS.  */
1095
 
1096
static void
1097
dbxout_typedefs (tree syms)
1098
{
1099
  for (; syms != NULL_TREE; syms = TREE_CHAIN (syms))
1100
    {
1101
      if (TREE_CODE (syms) == TYPE_DECL)
1102
        {
1103
          tree type = TREE_TYPE (syms);
1104
          if (TYPE_NAME (type)
1105
              && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1106
              && COMPLETE_OR_VOID_TYPE_P (type)
1107
              && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
1108
            dbxout_symbol (TYPE_NAME (type), 0);
1109
        }
1110
    }
1111
}
1112
 
1113
#ifdef DBX_USE_BINCL
1114
/* Emit BINCL stab using given name.  */
1115
static void
1116
emit_bincl_stab (const char *name)
1117
{
1118
  dbxout_begin_simple_stabs (name, N_BINCL);
1119
  dbxout_stab_value_zero ();
1120
}
1121
 
1122
/* If there are pending bincls then it is time to emit all of them.  */
1123
 
1124
static inline void
1125
emit_pending_bincls_if_required (void)
1126
{
1127
  if (pending_bincls)
1128
    emit_pending_bincls ();
1129
}
1130
 
1131
/* Emit all pending bincls.  */
1132
 
1133
static void
1134
emit_pending_bincls (void)
1135
{
1136
  struct dbx_file *f = current_file;
1137
 
1138
  /* Find first pending bincl.  */
1139
  while (f->bincl_status == BINCL_PENDING)
1140
    f = f->next;
1141
 
1142
  /* Now emit all bincls.  */
1143
  f = f->prev;
1144
 
1145
  while (f)
1146
    {
1147
      if (f->bincl_status == BINCL_PENDING)
1148
        {
1149
          emit_bincl_stab (f->pending_bincl_name);
1150
 
1151
          /* Update file number and status.  */
1152
          f->file_number = next_file_number++;
1153
          f->bincl_status = BINCL_PROCESSED;
1154
        }
1155
      if (f == current_file)
1156
        break;
1157
      f = f->prev;
1158
    }
1159
 
1160
  /* All pending bincls have been emitted.  */
1161
  pending_bincls = 0;
1162
}
1163
 
1164
#else
1165
 
1166
static inline void
1167
emit_pending_bincls_if_required (void) {}
1168
#endif
1169
 
1170
/* Change to reading from a new source file.  Generate a N_BINCL stab.  */
1171
 
1172
static void
1173
dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1174
                          const char *filename ATTRIBUTE_UNUSED)
1175
{
1176
#ifdef DBX_USE_BINCL
1177
  struct dbx_file *n = XNEW (struct dbx_file);
1178
 
1179
  n->next = current_file;
1180
  n->next_type_number = 1;
1181
  /* Do not assign file number now.
1182
     Delay it until we actually emit BINCL.  */
1183
  n->file_number = 0;
1184
  n->prev = NULL;
1185
  current_file->prev = n;
1186
  n->bincl_status = BINCL_PENDING;
1187
  n->pending_bincl_name = remap_debug_filename (filename);
1188
  pending_bincls = 1;
1189
  current_file = n;
1190
#endif
1191
}
1192
 
1193
/* Revert to reading a previous source file.  Generate a N_EINCL stab.  */
1194
 
1195
static void
1196
dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1197
{
1198
#ifdef DBX_USE_BINCL
1199
  /* Emit EINCL stab only if BINCL is not pending.  */
1200
  if (current_file->bincl_status == BINCL_PROCESSED)
1201
    {
1202
      dbxout_begin_stabn (N_EINCL);
1203
      dbxout_stab_value_zero ();
1204
    }
1205
  current_file->bincl_status = BINCL_NOT_REQUIRED;
1206
  current_file = current_file->next;
1207
#endif
1208
}
1209
 
1210
/* Handle a few odd cases that occur when trying to make PCH files work.  */
1211
 
1212
static void
1213
dbxout_handle_pch (unsigned at_end)
1214
{
1215
  if (! at_end)
1216
    {
1217
      /* When using the PCH, this file will be included, so we need to output
1218
         a BINCL.  */
1219
      dbxout_start_source_file (0, lastfile);
1220
 
1221
      /* The base file when using the PCH won't be the same as
1222
         the base file when it's being generated.  */
1223
      lastfile = NULL;
1224
    }
1225
  else
1226
    {
1227
      /* ... and an EINCL.  */
1228
      dbxout_end_source_file (0);
1229
 
1230
      /* Deal with cases where 'lastfile' was never actually changed.  */
1231
      lastfile_is_base = lastfile == NULL;
1232
    }
1233
}
1234
 
1235
#if defined (DBX_DEBUGGING_INFO)
1236
 
1237
static void dbxout_block (tree, int, tree);
1238
 
1239
/* Output debugging info to FILE to switch to sourcefile FILENAME.  */
1240
 
1241
static void
1242
dbxout_source_file (const char *filename)
1243
{
1244
  if (lastfile == 0 && lastfile_is_base)
1245
    {
1246
      lastfile = base_input_file;
1247
      lastfile_is_base = 0;
1248
    }
1249
 
1250
  if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
1251
    {
1252
      /* Don't change section amid function.  */
1253
      if (current_function_decl == NULL_TREE)
1254
        switch_to_section (text_section);
1255
 
1256
      dbxout_begin_simple_stabs (remap_debug_filename (filename), N_SOL);
1257
      dbxout_stab_value_internal_label ("Ltext", &source_label_number);
1258
      lastfile = filename;
1259
    }
1260
}
1261
 
1262
/* Output N_BNSYM, line number symbol entry, and local symbol at
1263
   function scope  */
1264
 
1265
static void
1266
dbxout_begin_prologue (unsigned int lineno, const char *filename)
1267
{
1268
  if (use_gnu_debug_info_extensions
1269
      && !NO_DBX_FUNCTION_END
1270
      && !NO_DBX_BNSYM_ENSYM
1271
      && !flag_debug_only_used_symbols)
1272
    dbxout_stabd (N_BNSYM, 0);
1273
 
1274
  /* pre-increment the scope counter */
1275
  scope_labelno++;
1276
 
1277
  dbxout_source_line (lineno, filename, 0, true);
1278
  /* Output function begin block at function scope, referenced
1279
     by dbxout_block, dbxout_source_line and dbxout_function_end.  */
1280
  emit_pending_bincls_if_required ();
1281
  targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
1282
}
1283
 
1284
/* Output a line number symbol entry for source file FILENAME and line
1285
   number LINENO.  */
1286
 
1287
static void
1288
dbxout_source_line (unsigned int lineno, const char *filename,
1289
                    int discriminator ATTRIBUTE_UNUSED,
1290
                    bool is_stmt ATTRIBUTE_UNUSED)
1291
{
1292
  dbxout_source_file (filename);
1293
 
1294
#ifdef DBX_OUTPUT_SOURCE_LINE
1295
  DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
1296
#else
1297
  if (DBX_LINES_FUNCTION_RELATIVE)
1298
    {
1299
      char begin_label[20];
1300
      dbxout_begin_stabn_sline (lineno);
1301
      /* Reference current function start using LFBB.  */
1302
      ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
1303
      dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
1304
                                             begin_label);
1305
    }
1306
  else
1307
    dbxout_stabd (N_SLINE, lineno);
1308
#endif
1309
}
1310
 
1311
/* Describe the beginning of an internal block within a function.  */
1312
 
1313
static void
1314
dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1315
{
1316
  emit_pending_bincls_if_required ();
1317
  targetm.asm_out.internal_label (asm_out_file, "LBB", n);
1318
}
1319
 
1320
/* Describe the end line-number of an internal block within a function.  */
1321
 
1322
static void
1323
dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1324
{
1325
  emit_pending_bincls_if_required ();
1326
  targetm.asm_out.internal_label (asm_out_file, "LBE", n);
1327
}
1328
 
1329
/* Output dbx data for a function definition.
1330
   This includes a definition of the function name itself (a symbol),
1331
   definitions of the parameters (locating them in the parameter list)
1332
   and then output the block that makes up the function's body
1333
   (including all the auto variables of the function).  */
1334
 
1335
static void
1336
dbxout_function_decl (tree decl)
1337
{
1338
  emit_pending_bincls_if_required ();
1339
#ifndef DBX_FUNCTION_FIRST
1340
  dbxout_begin_function (decl);
1341
#endif
1342
  dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
1343
  dbxout_function_end (decl);
1344
}
1345
 
1346
#endif /* DBX_DEBUGGING_INFO  */
1347
 
1348
/* Debug information for a global DECL.  Called from toplev.c after
1349
   compilation proper has finished.  */
1350
static void
1351
dbxout_global_decl (tree decl)
1352
{
1353
  if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1354
    {
1355
      int saved_tree_used = TREE_USED (decl);
1356
      TREE_USED (decl) = 1;
1357
      dbxout_symbol (decl, 0);
1358
      TREE_USED (decl) = saved_tree_used;
1359
    }
1360
}
1361
 
1362
/* This is just a function-type adapter; dbxout_symbol does exactly
1363
   what we want but returns an int.  */
1364
static void
1365
dbxout_type_decl (tree decl, int local)
1366
{
1367
  dbxout_symbol (decl, local);
1368
}
1369
 
1370
/* At the end of compilation, finish writing the symbol table.
1371
   The default is to call debug_free_queue but do nothing else.  */
1372
 
1373
static void
1374
dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
1375
{
1376
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1377
  DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
1378
#elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1379
 {
1380
   switch_to_section (text_section);
1381
   dbxout_begin_empty_stabs (N_SO);
1382
   dbxout_stab_value_internal_label ("Letext", 0);
1383
 }
1384
#endif
1385
  debug_free_queue ();
1386
}
1387
 
1388
/* Output the index of a type.  */
1389
 
1390
static void
1391
dbxout_type_index (tree type)
1392
{
1393
#ifndef DBX_USE_BINCL
1394
  stabstr_D (TYPE_SYMTAB_ADDRESS (type));
1395
#else
1396
  struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
1397
  stabstr_C ('(');
1398
  stabstr_D (t->file_number);
1399
  stabstr_C (',');
1400
  stabstr_D (t->type_number);
1401
  stabstr_C (')');
1402
#endif
1403
}
1404
 
1405
 
1406
 
1407
/* Used in several places: evaluates to '0' for a private decl,
1408
   '1' for a protected decl, '2' for a public decl.  */
1409
#define DECL_ACCESSIBILITY_CHAR(DECL) \
1410
(TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1411
 
1412
/* Subroutine of `dbxout_type'.  Output the type fields of TYPE.
1413
   This must be a separate function because anonymous unions require
1414
   recursive calls.  */
1415
 
1416
static void
1417
dbxout_type_fields (tree type)
1418
{
1419
  tree tem;
1420
 
1421
  /* Output the name, type, position (in bits), size (in bits) of each
1422
     field that we can support.  */
1423
  for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1424
    {
1425
      /* If one of the nodes is an error_mark or its type is then
1426
         return early.  */
1427
      if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node)
1428
        return;
1429
 
1430
      /* Omit here local type decls until we know how to support them.  */
1431
      if (TREE_CODE (tem) == TYPE_DECL
1432
          /* Omit here the nameless fields that are used to skip bits.  */
1433
          || DECL_IGNORED_P (tem)
1434
          /* Omit fields whose position or size are variable or too large to
1435
             represent.  */
1436
          || (TREE_CODE (tem) == FIELD_DECL
1437
              && (! host_integerp (bit_position (tem), 0)
1438
                  || ! DECL_SIZE (tem)
1439
                  || ! host_integerp (DECL_SIZE (tem), 1))))
1440
        continue;
1441
 
1442
      else if (TREE_CODE (tem) != CONST_DECL)
1443
        {
1444
          /* Continue the line if necessary,
1445
             but not before the first field.  */
1446
          if (tem != TYPE_FIELDS (type))
1447
            CONTIN;
1448
 
1449
          if (DECL_NAME (tem))
1450
            stabstr_I (DECL_NAME (tem));
1451
          stabstr_C (':');
1452
 
1453
          if (use_gnu_debug_info_extensions
1454
              && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
1455
                  || TREE_CODE (tem) != FIELD_DECL))
1456
            {
1457
              stabstr_C ('/');
1458
              stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
1459
            }
1460
 
1461
          dbxout_type ((TREE_CODE (tem) == FIELD_DECL
1462
                        && DECL_BIT_FIELD_TYPE (tem))
1463
                       ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
1464
 
1465
          if (TREE_CODE (tem) == VAR_DECL)
1466
            {
1467
              if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
1468
                {
1469
                  tree name = DECL_ASSEMBLER_NAME (tem);
1470
 
1471
                  stabstr_C (':');
1472
                  stabstr_I (name);
1473
                  stabstr_C (';');
1474
                }
1475
              else
1476
                /* If TEM is non-static, GDB won't understand it.  */
1477
                stabstr_S (",0,0;");
1478
            }
1479
          else
1480
            {
1481
              stabstr_C (',');
1482
              stabstr_D (int_bit_position (tem));
1483
              stabstr_C (',');
1484
              stabstr_D (tree_low_cst (DECL_SIZE (tem), 1));
1485
              stabstr_C (';');
1486
            }
1487
        }
1488
    }
1489
}
1490
 
1491
/* Subroutine of `dbxout_type_methods'.  Output debug info about the
1492
   method described DECL.  */
1493
 
1494
static void
1495
dbxout_type_method_1 (tree decl)
1496
{
1497
  char c1 = 'A', c2;
1498
 
1499
  if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
1500
    c2 = '?';
1501
  else /* it's a METHOD_TYPE.  */
1502
    {
1503
      tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
1504
      /* A for normal functions.
1505
         B for `const' member functions.
1506
         C for `volatile' member functions.
1507
         D for `const volatile' member functions.  */
1508
      if (TYPE_READONLY (TREE_TYPE (firstarg)))
1509
        c1 += 1;
1510
      if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
1511
        c1 += 2;
1512
 
1513
      if (DECL_VINDEX (decl))
1514
        c2 = '*';
1515
      else
1516
        c2 = '.';
1517
    }
1518
 
1519
  /* ??? Output the mangled name, which contains an encoding of the
1520
     method's type signature.  May not be necessary anymore.  */
1521
  stabstr_C (':');
1522
  stabstr_I (DECL_ASSEMBLER_NAME (decl));
1523
  stabstr_C (';');
1524
  stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
1525
  stabstr_C (c1);
1526
  stabstr_C (c2);
1527
 
1528
  if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
1529
    {
1530
      stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0));
1531
      stabstr_C (';');
1532
      dbxout_type (DECL_CONTEXT (decl), 0);
1533
      stabstr_C (';');
1534
    }
1535
}
1536
 
1537
/* Subroutine of `dbxout_type'.  Output debug info about the methods defined
1538
   in TYPE.  */
1539
 
1540
static void
1541
dbxout_type_methods (tree type)
1542
{
1543
  /* C++: put out the method names and their parameter lists */
1544
  tree methods = TYPE_METHODS (type);
1545
  tree fndecl;
1546
  tree last;
1547
 
1548
  if (methods == NULL_TREE)
1549
    return;
1550
 
1551
  if (TREE_CODE (methods) != TREE_VEC)
1552
    fndecl = methods;
1553
  else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
1554
    fndecl = TREE_VEC_ELT (methods, 0);
1555
  else
1556
    fndecl = TREE_VEC_ELT (methods, 1);
1557
 
1558
  while (fndecl)
1559
    {
1560
      int need_prefix = 1;
1561
 
1562
      /* Group together all the methods for the same operation.
1563
         These differ in the types of the arguments.  */
1564
      for (last = NULL_TREE;
1565
           fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
1566
           fndecl = TREE_CHAIN (fndecl))
1567
        /* Output the name of the field (after overloading), as
1568
           well as the name of the field before overloading, along
1569
           with its parameter list */
1570
        {
1571
          /* Skip methods that aren't FUNCTION_DECLs.  (In C++, these
1572
             include TEMPLATE_DECLs.)  The debugger doesn't know what
1573
             to do with such entities anyhow.  */
1574
          if (TREE_CODE (fndecl) != FUNCTION_DECL)
1575
            continue;
1576
 
1577
          CONTIN;
1578
 
1579
          last = fndecl;
1580
 
1581
          /* Also ignore abstract methods; those are only interesting to
1582
             the DWARF backends.  */
1583
          if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
1584
            continue;
1585
 
1586
          /* Redundantly output the plain name, since that's what gdb
1587
             expects.  */
1588
          if (need_prefix)
1589
            {
1590
              stabstr_I (DECL_NAME (fndecl));
1591
              stabstr_S ("::");
1592
              need_prefix = 0;
1593
            }
1594
 
1595
          dbxout_type (TREE_TYPE (fndecl), 0);
1596
          dbxout_type_method_1 (fndecl);
1597
        }
1598
      if (!need_prefix)
1599
        stabstr_C (';');
1600
    }
1601
}
1602
 
1603
/* Emit a "range" type specification, which has the form:
1604
   "r<index type>;<lower bound>;<upper bound>;".
1605
   TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds.  */
1606
 
1607
static void
1608
dbxout_range_type (tree type, tree low, tree high)
1609
{
1610
  stabstr_C ('r');
1611
  if (TREE_TYPE (type))
1612
    dbxout_type (TREE_TYPE (type), 0);
1613
  else if (TREE_CODE (type) != INTEGER_TYPE)
1614
    dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1615
  else
1616
    {
1617
      /* Traditionally, we made sure 'int' was type 1, and builtin types
1618
         were defined to be sub-ranges of int.  Unfortunately, this
1619
         does not allow us to distinguish true sub-ranges from integer
1620
         types.  So, instead we define integer (non-sub-range) types as
1621
         sub-ranges of themselves.  This matters for Chill.  If this isn't
1622
         a subrange type, then we want to define it in terms of itself.
1623
         However, in C, this may be an anonymous integer type, and we don't
1624
         want to emit debug info referring to it.  Just calling
1625
         dbxout_type_index won't work anyways, because the type hasn't been
1626
         defined yet.  We make this work for both cases by checked to see
1627
         whether this is a defined type, referring to it if it is, and using
1628
         'int' otherwise.  */
1629
      if (TYPE_SYMTAB_ADDRESS (type) != 0)
1630
        dbxout_type_index (type);
1631
      else
1632
        dbxout_type_index (integer_type_node);
1633
    }
1634
 
1635
  stabstr_C (';');
1636
  if (low && host_integerp (low, 0))
1637
    {
1638
      if (print_int_cst_bounds_in_octal_p (type, low, high))
1639
        stabstr_O (low);
1640
      else
1641
        stabstr_D (tree_low_cst (low, 0));
1642
    }
1643
  else
1644
    stabstr_C ('0');
1645
 
1646
  stabstr_C (';');
1647
  if (high && host_integerp (high, 0))
1648
    {
1649
      if (print_int_cst_bounds_in_octal_p (type, low, high))
1650
        stabstr_O (high);
1651
      else
1652
        stabstr_D (tree_low_cst (high, 0));
1653
      stabstr_C (';');
1654
    }
1655
  else
1656
    stabstr_S ("-1;");
1657
}
1658
 
1659
 
1660
/* Output a reference to a type.  If the type has not yet been
1661
   described in the dbx output, output its definition now.
1662
   For a type already defined, just refer to its definition
1663
   using the type number.
1664
 
1665
   If FULL is nonzero, and the type has been described only with
1666
   a forward-reference, output the definition now.
1667
   If FULL is zero in this case, just refer to the forward-reference
1668
   using the number previously allocated.  */
1669
 
1670
static void
1671
dbxout_type (tree type, int full)
1672
{
1673
  static int anonymous_type_number = 0;
1674
  bool vector_type = false;
1675
  tree tem, main_variant, low, high;
1676
 
1677
  if (TREE_CODE (type) == VECTOR_TYPE)
1678
    {
1679
      /* The frontend feeds us a representation for the vector as a struct
1680
         containing an array.  Pull out the array type.  */
1681
      type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
1682
      vector_type = true;
1683
    }
1684
 
1685
  if (TREE_CODE (type) == INTEGER_TYPE)
1686
    {
1687
      if (TREE_TYPE (type) == 0)
1688
        {
1689
          low = TYPE_MIN_VALUE (type);
1690
          high = TYPE_MAX_VALUE (type);
1691
        }
1692
 
1693
      else if (subrange_type_for_debug_p (type, &low, &high))
1694
        ;
1695
 
1696
      /* If this is a subtype that should not be emitted as a subrange type,
1697
         use the base type.  */
1698
      else
1699
        {
1700
          type = TREE_TYPE (type);
1701
          low = TYPE_MIN_VALUE (type);
1702
          high = TYPE_MAX_VALUE (type);
1703
        }
1704
    }
1705
 
1706
  /* If there was an input error and we don't really have a type,
1707
     avoid crashing and write something that is at least valid
1708
     by assuming `int'.  */
1709
  if (type == error_mark_node)
1710
    type = integer_type_node;
1711
  else
1712
    {
1713
      if (TYPE_NAME (type)
1714
          && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1715
          && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1716
        full = 0;
1717
    }
1718
 
1719
  /* Try to find the "main variant" with the same name.  */
1720
  if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1721
      && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1722
    main_variant = TREE_TYPE (TYPE_NAME (type));
1723
  else
1724
    main_variant = TYPE_MAIN_VARIANT (type);
1725
 
1726
  /* If we are not using extensions, stabs does not distinguish const and
1727
     volatile, so there is no need to make them separate types.  */
1728
  if (!use_gnu_debug_info_extensions)
1729
    type = main_variant;
1730
 
1731
  if (TYPE_SYMTAB_ADDRESS (type) == 0)
1732
    {
1733
      /* Type has no dbx number assigned.  Assign next available number.  */
1734
      TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1735
 
1736
      /* Make sure type vector is long enough to record about this type.  */
1737
 
1738
      if (next_type_number == typevec_len)
1739
        {
1740
          typevec = GGC_RESIZEVEC (struct typeinfo, typevec, typevec_len * 2);
1741
          memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1742
          typevec_len *= 2;
1743
        }
1744
 
1745
#ifdef DBX_USE_BINCL
1746
      emit_pending_bincls_if_required ();
1747
      typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1748
        = current_file->file_number;
1749
      typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1750
        = current_file->next_type_number++;
1751
#endif
1752
    }
1753
 
1754
  if (flag_debug_only_used_symbols)
1755
    {
1756
      if ((TREE_CODE (type) == RECORD_TYPE
1757
           || TREE_CODE (type) == UNION_TYPE
1758
           || TREE_CODE (type) == QUAL_UNION_TYPE
1759
           || TREE_CODE (type) == ENUMERAL_TYPE)
1760
          && TYPE_STUB_DECL (type)
1761
          && DECL_P (TYPE_STUB_DECL (type))
1762
          && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
1763
        debug_queue_symbol (TYPE_STUB_DECL (type));
1764
      else if (TYPE_NAME (type)
1765
               && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1766
        debug_queue_symbol (TYPE_NAME (type));
1767
    }
1768
 
1769
  /* Output the number of this type, to refer to it.  */
1770
  dbxout_type_index (type);
1771
 
1772
#ifdef DBX_TYPE_DEFINED
1773
  if (DBX_TYPE_DEFINED (type))
1774
    return;
1775
#endif
1776
 
1777
  /* If this type's definition has been output or is now being output,
1778
     that is all.  */
1779
 
1780
  switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1781
    {
1782
    case TYPE_UNSEEN:
1783
      break;
1784
    case TYPE_XREF:
1785
      /* If we have already had a cross reference,
1786
         and either that's all we want or that's the best we could do,
1787
         don't repeat the cross reference.
1788
         Sun dbx crashes if we do.  */
1789
      if (! full || !COMPLETE_TYPE_P (type)
1790
          /* No way in DBX fmt to describe a variable size.  */
1791
          || ! host_integerp (TYPE_SIZE (type), 1))
1792
        return;
1793
      break;
1794
    case TYPE_DEFINED:
1795
      return;
1796
    }
1797
 
1798
#ifdef DBX_NO_XREFS
1799
  /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1800
     leave the type-number completely undefined rather than output
1801
     a cross-reference.  If we have already used GNU debug info extensions,
1802
     then it is OK to output a cross reference.  This is necessary to get
1803
     proper C++ debug output.  */
1804
  if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1805
       || TREE_CODE (type) == QUAL_UNION_TYPE
1806
       || TREE_CODE (type) == ENUMERAL_TYPE)
1807
      && ! use_gnu_debug_info_extensions)
1808
    /* We must use the same test here as we use twice below when deciding
1809
       whether to emit a cross-reference.  */
1810
    if ((TYPE_NAME (type) != 0
1811
         && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1812
               && DECL_IGNORED_P (TYPE_NAME (type)))
1813
         && !full)
1814
        || !COMPLETE_TYPE_P (type)
1815
        /* No way in DBX fmt to describe a variable size.  */
1816
        || ! host_integerp (TYPE_SIZE (type), 1))
1817
      {
1818
        typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1819
        return;
1820
      }
1821
#endif
1822
 
1823
  /* Output a definition now.  */
1824
  stabstr_C ('=');
1825
 
1826
  /* Mark it as defined, so that if it is self-referent
1827
     we will not get into an infinite recursion of definitions.  */
1828
 
1829
  typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1830
 
1831
  /* If this type is a variant of some other, hand off.  Types with
1832
     different names are usefully distinguished.  We only distinguish
1833
     cv-qualified types if we're using extensions.  */
1834
  if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
1835
    {
1836
      stabstr_C ('k');
1837
      dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
1838
      return;
1839
    }
1840
  else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
1841
    {
1842
      stabstr_C ('B');
1843
      dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
1844
      return;
1845
    }
1846
  else if (main_variant != TYPE_MAIN_VARIANT (type))
1847
    {
1848
      if (flag_debug_only_used_symbols)
1849
        {
1850
          tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1851
 
1852
          if ((TREE_CODE (orig_type) == RECORD_TYPE
1853
               || TREE_CODE (orig_type) == UNION_TYPE
1854
               || TREE_CODE (orig_type) == QUAL_UNION_TYPE
1855
               || TREE_CODE (orig_type) == ENUMERAL_TYPE)
1856
              && TYPE_STUB_DECL (orig_type)
1857
              && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
1858
            debug_queue_symbol (TYPE_STUB_DECL (orig_type));
1859
        }
1860
      /* 'type' is a typedef; output the type it refers to.  */
1861
      dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1862
      return;
1863
    }
1864
  /* else continue.  */
1865
 
1866
  switch (TREE_CODE (type))
1867
    {
1868
    case VOID_TYPE:
1869
    case LANG_TYPE:
1870
      /* For a void type, just define it as itself; i.e., "5=5".
1871
         This makes us consider it defined
1872
         without saying what it is.  The debugger will make it
1873
         a void type when the reference is seen, and nothing will
1874
         ever override that default.  */
1875
      dbxout_type_index (type);
1876
      break;
1877
 
1878
    case INTEGER_TYPE:
1879
      if (type == char_type_node && ! TYPE_UNSIGNED (type))
1880
        {
1881
          /* Output the type `char' as a subrange of itself!
1882
             I don't understand this definition, just copied it
1883
             from the output of pcc.
1884
             This used to use `r2' explicitly and we used to
1885
             take care to make sure that `char' was type number 2.  */
1886
          stabstr_C ('r');
1887
          dbxout_type_index (type);
1888
          stabstr_S (";0;127;");
1889
        }
1890
 
1891
      /* If this is a subtype of another integer type, always prefer to
1892
         write it as a subtype.  */
1893
      else if (TREE_TYPE (type) != 0
1894
               && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1895
        {
1896
          /* If the size is non-standard, say what it is if we can use
1897
             GDB extensions.  */
1898
 
1899
          if (use_gnu_debug_info_extensions
1900
              && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1901
            {
1902
              stabstr_S ("@s");
1903
              stabstr_D (TYPE_PRECISION (type));
1904
              stabstr_C (';');
1905
            }
1906
 
1907
          dbxout_range_type (type, low, high);
1908
        }
1909
 
1910
      else
1911
        {
1912
          /* If the size is non-standard, say what it is if we can use
1913
             GDB extensions.  */
1914
 
1915
          if (use_gnu_debug_info_extensions
1916
              && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1917
            {
1918
              stabstr_S ("@s");
1919
              stabstr_D (TYPE_PRECISION (type));
1920
              stabstr_C (';');
1921
            }
1922
 
1923
          if (print_int_cst_bounds_in_octal_p (type, low, high))
1924
            {
1925
              stabstr_C ('r');
1926
 
1927
              /* If this type derives from another type, output type index of
1928
                 parent type. This is particularly important when parent type
1929
                 is an enumerated type, because not generating the parent type
1930
                 index would transform the definition of this enumerated type
1931
                 into a plain unsigned type.  */
1932
              if (TREE_TYPE (type) != 0)
1933
                dbxout_type_index (TREE_TYPE (type));
1934
              else
1935
                dbxout_type_index (type);
1936
 
1937
              stabstr_C (';');
1938
              stabstr_O (low);
1939
              stabstr_C (';');
1940
              stabstr_O (high);
1941
              stabstr_C (';');
1942
            }
1943
 
1944
          else
1945
            /* Output other integer types as subranges of `int'.  */
1946
            dbxout_range_type (type, low, high);
1947
        }
1948
 
1949
      break;
1950
 
1951
    case REAL_TYPE:
1952
    case FIXED_POINT_TYPE:
1953
      /* This used to say `r1' and we used to take care
1954
         to make sure that `int' was type number 1.  */
1955
      stabstr_C ('r');
1956
      dbxout_type_index (integer_type_node);
1957
      stabstr_C (';');
1958
      stabstr_D (int_size_in_bytes (type));
1959
      stabstr_S (";0;");
1960
      break;
1961
 
1962
    case BOOLEAN_TYPE:
1963
      if (use_gnu_debug_info_extensions)
1964
        {
1965
          stabstr_S ("@s");
1966
          stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1967
          stabstr_S (";-16;");
1968
        }
1969
      else /* Define as enumeral type (False, True) */
1970
        stabstr_S ("eFalse:0,True:1,;");
1971
      break;
1972
 
1973
    case COMPLEX_TYPE:
1974
      /* Differs from the REAL_TYPE by its new data type number.
1975
         R3 is NF_COMPLEX.  We don't try to use any of the other NF_*
1976
         codes since gdb doesn't care anyway.  */
1977
 
1978
      if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1979
        {
1980
          stabstr_S ("R3;");
1981
          stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
1982
          stabstr_S (";0;");
1983
        }
1984
      else
1985
        {
1986
          /* Output a complex integer type as a structure,
1987
             pending some other way to do it.  */
1988
          stabstr_C ('s');
1989
          stabstr_D (int_size_in_bytes (type));
1990
 
1991
          stabstr_S ("real:");
1992
          dbxout_type (TREE_TYPE (type), 0);
1993
          stabstr_S (",0,");
1994
          stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1995
 
1996
          stabstr_S (";imag:");
1997
          dbxout_type (TREE_TYPE (type), 0);
1998
          stabstr_C (',');
1999
          stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2000
          stabstr_C (',');
2001
          stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
2002
          stabstr_S (";;");
2003
        }
2004
      break;
2005
 
2006
    case ARRAY_TYPE:
2007
      /* Make arrays of packed bits look like bitstrings for chill.  */
2008
      if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
2009
        {
2010
          stabstr_S ("@s");
2011
          stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
2012
          stabstr_S (";@S;S");
2013
          dbxout_type (TYPE_DOMAIN (type), 0);
2014
          break;
2015
        }
2016
 
2017
      if (use_gnu_debug_info_extensions && vector_type)
2018
        stabstr_S ("@V;");
2019
 
2020
      /* Output "a" followed by a range type definition
2021
         for the index type of the array
2022
         followed by a reference to the target-type.
2023
         ar1;0;N;M for a C array of type M and size N+1.  */
2024
      /* Check if a character string type, which in Chill is
2025
         different from an array of characters.  */
2026
      if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
2027
        {
2028
          stabstr_S ("@S;");
2029
        }
2030
      tem = TYPE_DOMAIN (type);
2031
      if (tem == NULL)
2032
        {
2033
          stabstr_S ("ar");
2034
          dbxout_type_index (integer_type_node);
2035
          stabstr_S (";0;-1;");
2036
        }
2037
      else
2038
        {
2039
          stabstr_C ('a');
2040
          dbxout_range_type (tem, TYPE_MIN_VALUE (tem), TYPE_MAX_VALUE (tem));
2041
        }
2042
 
2043
      dbxout_type (TREE_TYPE (type), 0);
2044
      break;
2045
 
2046
    case RECORD_TYPE:
2047
    case UNION_TYPE:
2048
    case QUAL_UNION_TYPE:
2049
      {
2050
        tree binfo = TYPE_BINFO (type);
2051
 
2052
        /* Output a structure type.  We must use the same test here as we
2053
           use in the DBX_NO_XREFS case above.  */
2054
        if ((TYPE_NAME (type) != 0
2055
             && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2056
                   && DECL_IGNORED_P (TYPE_NAME (type)))
2057
             && !full)
2058
            || !COMPLETE_TYPE_P (type)
2059
            /* No way in DBX fmt to describe a variable size.  */
2060
            || ! host_integerp (TYPE_SIZE (type), 1))
2061
          {
2062
            /* If the type is just a cross reference, output one
2063
               and mark the type as partially described.
2064
               If it later becomes defined, we will output
2065
               its real definition.
2066
               If the type has a name, don't nest its definition within
2067
               another type's definition; instead, output an xref
2068
               and let the definition come when the name is defined.  */
2069
            stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
2070
            if (TYPE_NAME (type) != 0
2071
                /* The C frontend creates for anonymous variable length
2072
                   records/unions TYPE_NAME with DECL_NAME NULL.  */
2073
                && (TREE_CODE (TYPE_NAME (type)) != TYPE_DECL
2074
                    || DECL_NAME (TYPE_NAME (type))))
2075
              dbxout_type_name (type);
2076
            else
2077
              {
2078
                stabstr_S ("$$");
2079
                stabstr_D (anonymous_type_number++);
2080
              }
2081
 
2082
            stabstr_C (':');
2083
            typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2084
            break;
2085
          }
2086
 
2087
        /* Identify record or union, and print its size.  */
2088
        stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
2089
        stabstr_D (int_size_in_bytes (type));
2090
 
2091
        if (binfo)
2092
          {
2093
            int i;
2094
            tree child;
2095
            VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
2096
 
2097
            if (use_gnu_debug_info_extensions)
2098
              {
2099
                if (BINFO_N_BASE_BINFOS (binfo))
2100
                  {
2101
                    stabstr_C ('!');
2102
                    stabstr_U (BINFO_N_BASE_BINFOS (binfo));
2103
                    stabstr_C (',');
2104
                  }
2105
              }
2106
            for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
2107
              {
2108
                tree access = (accesses ? VEC_index (tree, accesses, i)
2109
                               : access_public_node);
2110
 
2111
                if (use_gnu_debug_info_extensions)
2112
                  {
2113
                    stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
2114
                    stabstr_C (access == access_public_node ? '2' :
2115
                                   access == access_protected_node
2116
                                   ? '1' :'0');
2117
                    if (BINFO_VIRTUAL_P (child)
2118
                        && (strcmp (lang_hooks.name, "GNU C++") == 0
2119
                            || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
2120
                      /* For a virtual base, print the (negative)
2121
                         offset within the vtable where we must look
2122
                         to find the necessary adjustment.  */
2123
                      stabstr_D
2124
                        (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
2125
                         * BITS_PER_UNIT);
2126
                    else
2127
                      stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2128
                                       * BITS_PER_UNIT);
2129
                    stabstr_C (',');
2130
                    dbxout_type (BINFO_TYPE (child), 0);
2131
                    stabstr_C (';');
2132
                  }
2133
                else
2134
                  {
2135
                    /* Print out the base class information with
2136
                       fields which have the same names at the types
2137
                       they hold.  */
2138
                    dbxout_type_name (BINFO_TYPE (child));
2139
                    stabstr_C (':');
2140
                    dbxout_type (BINFO_TYPE (child), full);
2141
                    stabstr_C (',');
2142
                    stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2143
                                     * BITS_PER_UNIT);
2144
                    stabstr_C (',');
2145
                    stabstr_D
2146
                      (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0)
2147
                       * BITS_PER_UNIT);
2148
                    stabstr_C (';');
2149
                  }
2150
              }
2151
          }
2152
      }
2153
 
2154
      /* Write out the field declarations.  */
2155
      dbxout_type_fields (type);
2156
      if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
2157
        {
2158
          dbxout_type_methods (type);
2159
        }
2160
 
2161
      stabstr_C (';');
2162
 
2163
      if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
2164
          /* Avoid the ~ if we don't really need it--it confuses dbx.  */
2165
          && TYPE_VFIELD (type))
2166
        {
2167
 
2168
          /* We need to write out info about what field this class
2169
             uses as its "main" vtable pointer field, because if this
2170
             field is inherited from a base class, GDB cannot necessarily
2171
             figure out which field it's using in time.  */
2172
          stabstr_S ("~%");
2173
          dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
2174
          stabstr_C (';');
2175
        }
2176
      break;
2177
 
2178
    case ENUMERAL_TYPE:
2179
      /* We must use the same test here as we use in the DBX_NO_XREFS case
2180
         above.  We simplify it a bit since an enum will never have a variable
2181
         size.  */
2182
      if ((TYPE_NAME (type) != 0
2183
           && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2184
                 && DECL_IGNORED_P (TYPE_NAME (type)))
2185
           && !full)
2186
          || !COMPLETE_TYPE_P (type))
2187
        {
2188
          stabstr_S ("xe");
2189
          dbxout_type_name (type);
2190
          typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2191
          stabstr_C (':');
2192
          return;
2193
        }
2194
      if (use_gnu_debug_info_extensions
2195
          && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
2196
        {
2197
          stabstr_S ("@s");
2198
          stabstr_D (TYPE_PRECISION (type));
2199
          stabstr_C (';');
2200
        }
2201
 
2202
      stabstr_C ('e');
2203
      for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
2204
        {
2205
          tree value = TREE_VALUE (tem);
2206
 
2207
          stabstr_I (TREE_PURPOSE (tem));
2208
          stabstr_C (':');
2209
 
2210
          if (TREE_CODE (value) == CONST_DECL)
2211
            value = DECL_INITIAL (value);
2212
 
2213
          if (TREE_INT_CST_HIGH (value) == 0)
2214
            stabstr_D (TREE_INT_CST_LOW (value));
2215
          else if (TREE_INT_CST_HIGH (value) == -1
2216
                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (value) < 0)
2217
            stabstr_D (TREE_INT_CST_LOW (value));
2218
          else
2219
            stabstr_O (value);
2220
 
2221
          stabstr_C (',');
2222
          if (TREE_CHAIN (tem) != 0)
2223
            CONTIN;
2224
        }
2225
 
2226
      stabstr_C (';');
2227
      break;
2228
 
2229
    case POINTER_TYPE:
2230
      stabstr_C ('*');
2231
      dbxout_type (TREE_TYPE (type), 0);
2232
      break;
2233
 
2234
    case METHOD_TYPE:
2235
      if (use_gnu_debug_info_extensions)
2236
        {
2237
          stabstr_C ('#');
2238
 
2239
          /* Write the argument types out longhand.  */
2240
          dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
2241
          stabstr_C (',');
2242
          dbxout_type (TREE_TYPE (type), 0);
2243
          dbxout_args (TYPE_ARG_TYPES (type));
2244
          stabstr_C (';');
2245
        }
2246
      else
2247
        /* Treat it as a function type.  */
2248
        dbxout_type (TREE_TYPE (type), 0);
2249
      break;
2250
 
2251
    case OFFSET_TYPE:
2252
      if (use_gnu_debug_info_extensions)
2253
        {
2254
          stabstr_C ('@');
2255
          dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
2256
          stabstr_C (',');
2257
          dbxout_type (TREE_TYPE (type), 0);
2258
        }
2259
      else
2260
        /* Should print as an int, because it is really just an offset.  */
2261
        dbxout_type (integer_type_node, 0);
2262
      break;
2263
 
2264
    case REFERENCE_TYPE:
2265
      if (use_gnu_debug_info_extensions)
2266
        {
2267
          stabstr_C ('&');
2268
        }
2269
      else
2270
        stabstr_C ('*');
2271
      dbxout_type (TREE_TYPE (type), 0);
2272
      break;
2273
 
2274
    case FUNCTION_TYPE:
2275
      stabstr_C ('f');
2276
      dbxout_type (TREE_TYPE (type), 0);
2277
      break;
2278
 
2279
    default:
2280
      gcc_unreachable ();
2281
    }
2282
}
2283
 
2284
/* Return nonzero if the given type represents an integer whose bounds
2285
   should be printed in octal format.  */
2286
 
2287
static bool
2288
print_int_cst_bounds_in_octal_p (tree type, tree low, tree high)
2289
{
2290
  /* If we can use GDB extensions and the size is wider than a long
2291
     (the size used by GDB to read them) or we may have trouble writing
2292
     the bounds the usual way, write them in octal.  Note the test is for
2293
     the *target's* size of "long", not that of the host.  The host test
2294
     is just to make sure we can write it out in case the host wide int
2295
     is narrower than the target "long".
2296
 
2297
     For unsigned types, we use octal if they are the same size or larger.
2298
     This is because we print the bounds as signed decimal, and hence they
2299
     can't span same size unsigned types.  */
2300
 
2301
  if (use_gnu_debug_info_extensions
2302
      && low && TREE_CODE (low) == INTEGER_CST
2303
      && high && TREE_CODE (high) == INTEGER_CST
2304
      && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
2305
          || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2306
              && TYPE_UNSIGNED (type))
2307
          || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
2308
          || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
2309
              && TYPE_UNSIGNED (type))))
2310
    return TRUE;
2311
  else
2312
    return FALSE;
2313
}
2314
 
2315
/* Output the name of type TYPE, with no punctuation.
2316
   Such names can be set up either by typedef declarations
2317
   or by struct, enum and union tags.  */
2318
 
2319
static void
2320
dbxout_type_name (tree type)
2321
{
2322
  tree t = TYPE_NAME (type);
2323
 
2324
  gcc_assert (t);
2325
  switch (TREE_CODE (t))
2326
    {
2327
    case IDENTIFIER_NODE:
2328
      break;
2329
    case TYPE_DECL:
2330
      t = DECL_NAME (t);
2331
      break;
2332
    default:
2333
      gcc_unreachable ();
2334
    }
2335
 
2336
  stabstr_I (t);
2337
}
2338
 
2339
/* Output leading leading struct or class names needed for qualifying
2340
   type whose scope is limited to a struct or class.  */
2341
 
2342
static void
2343
dbxout_class_name_qualifiers (tree decl)
2344
{
2345
  tree context = decl_type_context (decl);
2346
 
2347
  if (context != NULL_TREE
2348
      && TREE_CODE(context) == RECORD_TYPE
2349
      && TYPE_NAME (context) != 0
2350
      && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2351
          || (DECL_NAME (TYPE_NAME (context)) != 0)))
2352
    {
2353
      tree name = TYPE_NAME (context);
2354
 
2355
      if (TREE_CODE (name) == TYPE_DECL)
2356
        {
2357
          dbxout_class_name_qualifiers (name);
2358
          name = DECL_NAME (name);
2359
        }
2360
      stabstr_I (name);
2361
      stabstr_S ("::");
2362
    }
2363
}
2364
 
2365
/* This is a specialized subset of expand_expr for use by dbxout_symbol in
2366
   evaluating DECL_VALUE_EXPR.  In particular, we stop if we find decls that
2367
   haven't been expanded, or if the expression is getting so complex we won't
2368
   be able to represent it in stabs anyway.  Returns NULL on failure.  */
2369
 
2370
static rtx
2371
dbxout_expand_expr (tree expr)
2372
{
2373
  switch (TREE_CODE (expr))
2374
    {
2375
    case VAR_DECL:
2376
      /* We can't handle emulated tls variables, because the address is an
2377
         offset to the return value of __emutls_get_address, and there is no
2378
         way to express that in stabs.  Also, there are name mangling issues
2379
         here.  We end up with references to undefined symbols if we don't
2380
         disable debug info for these variables.  */
2381
      if (!targetm.have_tls && DECL_THREAD_LOCAL_P (expr))
2382
        return NULL;
2383
      /* FALLTHRU */
2384
 
2385
    case PARM_DECL:
2386
      if (DECL_HAS_VALUE_EXPR_P (expr))
2387
        return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
2388
      /* FALLTHRU */
2389
 
2390
    case CONST_DECL:
2391
    case RESULT_DECL:
2392
      return DECL_RTL_IF_SET (expr);
2393
 
2394
    case INTEGER_CST:
2395
      return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2396
 
2397
    case COMPONENT_REF:
2398
    case ARRAY_REF:
2399
    case ARRAY_RANGE_REF:
2400
    case BIT_FIELD_REF:
2401
      {
2402
        enum machine_mode mode;
2403
        HOST_WIDE_INT bitsize, bitpos;
2404
        tree offset, tem;
2405
        int volatilep = 0, unsignedp = 0;
2406
        rtx x;
2407
 
2408
        tem = get_inner_reference (expr, &bitsize, &bitpos, &offset,
2409
                                   &mode, &unsignedp, &volatilep, true);
2410
 
2411
        x = dbxout_expand_expr (tem);
2412
        if (x == NULL || !MEM_P (x))
2413
          return NULL;
2414
        if (offset != NULL)
2415
          {
2416
            if (!host_integerp (offset, 0))
2417
              return NULL;
2418
            x = adjust_address_nv (x, mode, tree_low_cst (offset, 0));
2419
          }
2420
        if (bitpos != 0)
2421
          x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT);
2422
 
2423
        return x;
2424
      }
2425
 
2426
    default:
2427
      return NULL;
2428
    }
2429
}
2430
 
2431
/* Helper function for output_used_types.  Queue one entry from the
2432
   used types hash to be output.  */
2433
 
2434
static int
2435
output_used_types_helper (void **slot, void *data)
2436
{
2437
  tree type = (tree) *slot;
2438
  VEC(tree, heap) **types_p = (VEC(tree, heap) **) data;
2439
 
2440
  if ((TREE_CODE (type) == RECORD_TYPE
2441
       || TREE_CODE (type) == UNION_TYPE
2442
       || TREE_CODE (type) == QUAL_UNION_TYPE
2443
       || TREE_CODE (type) == ENUMERAL_TYPE)
2444
      && TYPE_STUB_DECL (type)
2445
      && DECL_P (TYPE_STUB_DECL (type))
2446
      && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
2447
    VEC_quick_push (tree, *types_p, TYPE_STUB_DECL (type));
2448
  else if (TYPE_NAME (type)
2449
           && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2450
    VEC_quick_push (tree, *types_p, TYPE_NAME (type));
2451
 
2452
  return 1;
2453
}
2454
 
2455
/* This is a qsort callback which sorts types and declarations into a
2456
   predictable order (types, then declarations, sorted by UID
2457
   within).  */
2458
 
2459
static int
2460
output_types_sort (const void *pa, const void *pb)
2461
{
2462
  const tree lhs = *((const tree *)pa);
2463
  const tree rhs = *((const tree *)pb);
2464
 
2465
  if (TYPE_P (lhs))
2466
    {
2467
      if (TYPE_P (rhs))
2468
        return TYPE_UID (lhs) - TYPE_UID (rhs);
2469
      else
2470
        return 1;
2471
    }
2472
  else
2473
    {
2474
      if (TYPE_P (rhs))
2475
        return -1;
2476
      else
2477
        return DECL_UID (lhs) - DECL_UID (rhs);
2478
    }
2479
}
2480
 
2481
 
2482
/* Force all types used by this function to be output in debug
2483
   information.  */
2484
 
2485
static void
2486
output_used_types (void)
2487
{
2488
  if (cfun && cfun->used_types_hash)
2489
    {
2490
      VEC(tree, heap) *types;
2491
      int i;
2492
      tree type;
2493
 
2494
      types = VEC_alloc (tree, heap, htab_elements (cfun->used_types_hash));
2495
      htab_traverse (cfun->used_types_hash, output_used_types_helper, &types);
2496
 
2497
      /* Sort by UID to prevent dependence on hash table ordering.  */
2498
      qsort (VEC_address (tree, types), VEC_length (tree, types),
2499
             sizeof (tree), output_types_sort);
2500
 
2501
      for (i = 0; VEC_iterate (tree, types, i, type); i++)
2502
        debug_queue_symbol (type);
2503
 
2504
      VEC_free (tree, heap, types);
2505
    }
2506
}
2507
 
2508
/* Output a .stabs for the symbol defined by DECL,
2509
   which must be a ..._DECL node in the normal namespace.
2510
   It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2511
   LOCAL is nonzero if the scope is less than the entire file.
2512
   Return 1 if a stabs might have been emitted.  */
2513
 
2514
int
2515
dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2516
{
2517
  tree type = TREE_TYPE (decl);
2518
  tree context = NULL_TREE;
2519
  int result = 0;
2520
  rtx decl_rtl;
2521
 
2522
  /* "Intercept" dbxout_symbol() calls like we do all debug_hooks.  */
2523
  ++debug_nesting;
2524
 
2525
  /* Ignore nameless syms, but don't ignore type tags.  */
2526
 
2527
  if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2528
      || DECL_IGNORED_P (decl))
2529
    DBXOUT_DECR_NESTING_AND_RETURN (0);
2530
 
2531
  /* If we are to generate only the symbols actually used then such
2532
     symbol nodes are flagged with TREE_USED.  Ignore any that
2533
     aren't flagged as TREE_USED.  */
2534
 
2535
  if (flag_debug_only_used_symbols
2536
      && (!TREE_USED (decl)
2537
          && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
2538
    DBXOUT_DECR_NESTING_AND_RETURN (0);
2539
 
2540
  /* If dbxout_init has not yet run, queue this symbol for later.  */
2541
  if (!typevec)
2542
    {
2543
      preinit_symbols = tree_cons (0, decl, preinit_symbols);
2544
      DBXOUT_DECR_NESTING_AND_RETURN (0);
2545
    }
2546
 
2547
  if (flag_debug_only_used_symbols)
2548
    {
2549
      tree t;
2550
 
2551
      /* We now have a used symbol.  We need to generate the info for
2552
         the symbol's type in addition to the symbol itself.  These
2553
         type symbols are queued to be generated after were done with
2554
         the symbol itself (otherwise they would fight over the
2555
         stabstr obstack).
2556
 
2557
         Note, because the TREE_TYPE(type) might be something like a
2558
         pointer to a named type we need to look for the first name
2559
         we see following the TREE_TYPE chain.  */
2560
 
2561
      t = type;
2562
      while (POINTER_TYPE_P (t))
2563
        t = TREE_TYPE (t);
2564
 
2565
      /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2566
         need special treatment.  The TYPE_STUB_DECL field in these
2567
         types generally represents the tag name type we want to
2568
         output.  In addition there  could be a typedef type with
2569
         a different name.  In that case we also want to output
2570
         that.  */
2571
 
2572
      if (TREE_CODE (t) == RECORD_TYPE
2573
           || TREE_CODE (t) == UNION_TYPE
2574
           || TREE_CODE (t) == QUAL_UNION_TYPE
2575
           || TREE_CODE (t) == ENUMERAL_TYPE)
2576
        {
2577
            if (TYPE_STUB_DECL (t)
2578
                && TYPE_STUB_DECL (t) != decl
2579
                && DECL_P (TYPE_STUB_DECL (t))
2580
                && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2581
            {
2582
              debug_queue_symbol (TYPE_STUB_DECL (t));
2583
              if (TYPE_NAME (t)
2584
                  && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2585
                  && TYPE_NAME (t) != decl
2586
                  && DECL_P (TYPE_NAME (t)))
2587
                debug_queue_symbol (TYPE_NAME (t));
2588
            }
2589
        }
2590
      else if (TYPE_NAME (t)
2591
               && TYPE_NAME (t) != decl
2592
               && DECL_P (TYPE_NAME (t)))
2593
        debug_queue_symbol (TYPE_NAME (t));
2594
    }
2595
 
2596
  emit_pending_bincls_if_required ();
2597
 
2598
  switch (TREE_CODE (decl))
2599
    {
2600
    case CONST_DECL:
2601
      /* Enum values are defined by defining the enum type.  */
2602
      break;
2603
 
2604
    case FUNCTION_DECL:
2605
      decl_rtl = DECL_RTL_IF_SET (decl);
2606
      if (!decl_rtl)
2607
        DBXOUT_DECR_NESTING_AND_RETURN (0);
2608
      if (DECL_EXTERNAL (decl))
2609
        break;
2610
      /* Don't mention a nested function under its parent.  */
2611
      context = decl_function_context (decl);
2612
      if (context == current_function_decl)
2613
        break;
2614
      /* Don't mention an inline instance of a nested function.  */
2615
      if (context && DECL_FROM_INLINE (decl))
2616
        break;
2617
      if (!MEM_P (decl_rtl)
2618
          || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
2619
        break;
2620
 
2621
      if (flag_debug_only_used_symbols)
2622
        output_used_types ();
2623
 
2624
      dbxout_begin_complex_stabs ();
2625
      stabstr_I (DECL_ASSEMBLER_NAME (decl));
2626
      stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
2627
      result = 1;
2628
 
2629
      if (TREE_TYPE (type))
2630
        dbxout_type (TREE_TYPE (type), 0);
2631
      else
2632
        dbxout_type (void_type_node, 0);
2633
 
2634
      /* For a nested function, when that function is compiled,
2635
         mention the containing function name
2636
         as well as (since dbx wants it) our own assembler-name.  */
2637
      if (context != 0)
2638
        {
2639
          stabstr_C (',');
2640
          stabstr_I (DECL_ASSEMBLER_NAME (decl));
2641
          stabstr_C (',');
2642
          stabstr_I (DECL_NAME (context));
2643
        }
2644
 
2645
      dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0);
2646
      break;
2647
 
2648
    case TYPE_DECL:
2649
      /* Don't output the same typedef twice.
2650
         And don't output what language-specific stuff doesn't want output.  */
2651
      if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2652
        DBXOUT_DECR_NESTING_AND_RETURN (0);
2653
 
2654
      /* Don't output typedefs for types with magic type numbers (XCOFF).  */
2655
#ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2656
      {
2657
        int fundamental_type_number =
2658
          DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2659
 
2660
        if (fundamental_type_number != 0)
2661
          {
2662
            TREE_ASM_WRITTEN (decl) = 1;
2663
            TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2664
            DBXOUT_DECR_NESTING_AND_RETURN (0);
2665
          }
2666
      }
2667
#endif
2668
      FORCE_TEXT;
2669
      result = 1;
2670
      {
2671
        int tag_needed = 1;
2672
        int did_output = 0;
2673
 
2674
        if (DECL_NAME (decl))
2675
          {
2676
            /* Nonzero means we must output a tag as well as a typedef.  */
2677
            tag_needed = 0;
2678
 
2679
            /* Handle the case of a C++ structure or union
2680
               where the TYPE_NAME is a TYPE_DECL
2681
               which gives both a typedef name and a tag.  */
2682
            /* dbx requires the tag first and the typedef second.  */
2683
            if ((TREE_CODE (type) == RECORD_TYPE
2684
                 || TREE_CODE (type) == UNION_TYPE
2685
                 || TREE_CODE (type) == QUAL_UNION_TYPE)
2686
                && TYPE_NAME (type) == decl
2687
                && !use_gnu_debug_info_extensions
2688
                && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2689
                /* Distinguish the implicit typedefs of C++
2690
                   from explicit ones that might be found in C.  */
2691
                && DECL_ARTIFICIAL (decl)
2692
                /* Do not generate a tag for incomplete records.  */
2693
                && COMPLETE_TYPE_P (type)
2694
                /* Do not generate a tag for records of variable size,
2695
                   since this type can not be properly described in the
2696
                   DBX format, and it confuses some tools such as objdump.  */
2697
                && host_integerp (TYPE_SIZE (type), 1))
2698
              {
2699
                tree name = TYPE_NAME (type);
2700
                if (TREE_CODE (name) == TYPE_DECL)
2701
                  name = DECL_NAME (name);
2702
 
2703
                dbxout_begin_complex_stabs ();
2704
                stabstr_I (name);
2705
                stabstr_S (":T");
2706
                dbxout_type (type, 1);
2707
                dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
2708
                                             0, 0, 0);
2709
              }
2710
 
2711
            dbxout_begin_complex_stabs ();
2712
 
2713
            /* Output leading class/struct qualifiers.  */
2714
            if (use_gnu_debug_info_extensions)
2715
              dbxout_class_name_qualifiers (decl);
2716
 
2717
            /* Output typedef name.  */
2718
            stabstr_I (DECL_NAME (decl));
2719
            stabstr_C (':');
2720
 
2721
            /* Short cut way to output a tag also.  */
2722
            if ((TREE_CODE (type) == RECORD_TYPE
2723
                 || TREE_CODE (type) == UNION_TYPE
2724
                 || TREE_CODE (type) == QUAL_UNION_TYPE)
2725
                && TYPE_NAME (type) == decl
2726
                /* Distinguish the implicit typedefs of C++
2727
                   from explicit ones that might be found in C.  */
2728
                && DECL_ARTIFICIAL (decl))
2729
              {
2730
                if (use_gnu_debug_info_extensions)
2731
                  {
2732
                    stabstr_C ('T');
2733
                    TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2734
                  }
2735
              }
2736
 
2737
            stabstr_C ('t');
2738
            dbxout_type (type, 1);
2739
            dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
2740
                                         0, 0, 0);
2741
            did_output = 1;
2742
          }
2743
 
2744
        /* Don't output a tag if this is an incomplete type.  This prevents
2745
           the sun4 Sun OS 4.x dbx from crashing.  */
2746
 
2747
        if (tag_needed && TYPE_NAME (type) != 0
2748
            && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2749
                || (DECL_NAME (TYPE_NAME (type)) != 0))
2750
            && COMPLETE_TYPE_P (type)
2751
            && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2752
          {
2753
            /* For a TYPE_DECL with no name, but the type has a name,
2754
               output a tag.
2755
               This is what represents `struct foo' with no typedef.  */
2756
            /* In C++, the name of a type is the corresponding typedef.
2757
               In C, it is an IDENTIFIER_NODE.  */
2758
            tree name = TYPE_NAME (type);
2759
            if (TREE_CODE (name) == TYPE_DECL)
2760
              name = DECL_NAME (name);
2761
 
2762
            dbxout_begin_complex_stabs ();
2763
            stabstr_I (name);
2764
            stabstr_S (":T");
2765
            dbxout_type (type, 1);
2766
            dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2767
            did_output = 1;
2768
          }
2769
 
2770
        /* If an enum type has no name, it cannot be referred to, but
2771
           we must output it anyway, to record the enumeration
2772
           constants.  */
2773
 
2774
        if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2775
          {
2776
            dbxout_begin_complex_stabs ();
2777
            /* Some debuggers fail when given NULL names, so give this a
2778
               harmless name of " " (Why not "(anon)"?).  */
2779
            stabstr_S (" :T");
2780
            dbxout_type (type, 1);
2781
            dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2782
          }
2783
 
2784
        /* Prevent duplicate output of a typedef.  */
2785
        TREE_ASM_WRITTEN (decl) = 1;
2786
        break;
2787
      }
2788
 
2789
    case PARM_DECL:
2790
      if (DECL_HAS_VALUE_EXPR_P (decl))
2791
        decl = DECL_VALUE_EXPR (decl);
2792
 
2793
      /* PARM_DECLs go in their own separate chain and are output by
2794
         dbxout_reg_parms and dbxout_parms, except for those that are
2795
         disguised VAR_DECLs like Out parameters in Ada.  */
2796
      gcc_assert (TREE_CODE (decl) == VAR_DECL);
2797
 
2798
      /* ... fall through ...  */
2799
 
2800
    case RESULT_DECL:
2801
    case VAR_DECL:
2802
      /* Don't mention a variable that is external.
2803
         Let the file that defines it describe it.  */
2804
      if (DECL_EXTERNAL (decl))
2805
        break;
2806
 
2807
      /* If the variable is really a constant
2808
         and not written in memory, inform the debugger.
2809
 
2810
         ??? Why do we skip emitting the type and location in this case?  */
2811
      if (TREE_STATIC (decl) && TREE_READONLY (decl)
2812
          && DECL_INITIAL (decl) != 0
2813
          && host_integerp (DECL_INITIAL (decl), 0)
2814
          && ! TREE_ASM_WRITTEN (decl)
2815
          && (DECL_CONTEXT (decl) == NULL_TREE
2816
              || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
2817
              || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
2818
          && TREE_PUBLIC (decl) == 0)
2819
        {
2820
          /* The sun4 assembler does not grok this.  */
2821
 
2822
          if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2823
              || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2824
            {
2825
              HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
2826
 
2827
              dbxout_begin_complex_stabs ();
2828
              dbxout_symbol_name (decl, NULL, 'c');
2829
              stabstr_S ("=i");
2830
              stabstr_D (ival);
2831
              dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
2832
              DBXOUT_DECR_NESTING;
2833
              return 1;
2834
            }
2835
          else
2836
            break;
2837
        }
2838
      /* else it is something we handle like a normal variable.  */
2839
 
2840
      decl_rtl = dbxout_expand_expr (decl);
2841
      if (!decl_rtl)
2842
        DBXOUT_DECR_NESTING_AND_RETURN (0);
2843
 
2844
      decl_rtl = eliminate_regs (decl_rtl, VOIDmode, NULL_RTX);
2845
#ifdef LEAF_REG_REMAP
2846
      if (current_function_uses_only_leaf_regs)
2847
        leaf_renumber_regs_insn (decl_rtl);
2848
#endif
2849
 
2850
      result = dbxout_symbol_location (decl, type, 0, decl_rtl);
2851
      break;
2852
 
2853
    default:
2854
      break;
2855
    }
2856
  DBXOUT_DECR_NESTING;
2857
  return result;
2858
}
2859
 
2860
/* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2861
   Add SUFFIX to its name, if SUFFIX is not 0.
2862
   Describe the variable as residing in HOME
2863
   (usually HOME is DECL_RTL (DECL), but not always).
2864
   Returns 1 if the stab was really emitted.  */
2865
 
2866
static int
2867
dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2868
{
2869
  int letter = 0;
2870
  stab_code_type code;
2871
  rtx addr = 0;
2872
  int number = 0;
2873
  int regno = -1;
2874
 
2875
  /* Don't mention a variable at all
2876
     if it was completely optimized into nothingness.
2877
 
2878
     If the decl was from an inline function, then its rtl
2879
     is not identically the rtl that was used in this
2880
     particular compilation.  */
2881
  if (GET_CODE (home) == SUBREG)
2882
    {
2883
      rtx value = home;
2884
 
2885
      while (GET_CODE (value) == SUBREG)
2886
        value = SUBREG_REG (value);
2887
      if (REG_P (value))
2888
        {
2889
          if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2890
            return 0;
2891
        }
2892
      home = alter_subreg (&home);
2893
    }
2894
  if (REG_P (home))
2895
    {
2896
      regno = REGNO (home);
2897
      if (regno >= FIRST_PSEUDO_REGISTER)
2898
        return 0;
2899
    }
2900
 
2901
  /* The kind-of-variable letter depends on where
2902
     the variable is and on the scope of its name:
2903
     G and N_GSYM for static storage and global scope,
2904
     S for static storage and file scope,
2905
     V for static storage and local scope,
2906
     for those two, use N_LCSYM if data is in bss segment,
2907
     N_STSYM if in data segment, N_FUN otherwise.
2908
     (We used N_FUN originally, then changed to N_STSYM
2909
     to please GDB.  However, it seems that confused ld.
2910
     Now GDB has been fixed to like N_FUN, says Kingdon.)
2911
     no letter at all, and N_LSYM, for auto variable,
2912
     r and N_RSYM for register variable.  */
2913
 
2914
  if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2915
    {
2916
      if (TREE_PUBLIC (decl))
2917
        {
2918
          int offs;
2919
          letter = 'G';
2920
          code = N_GSYM;
2921
          if (NULL != dbxout_common_check (decl, &offs))
2922
            {
2923
              letter = 'V';
2924
              addr = 0;
2925
              number = offs;
2926
            }
2927
        }
2928
      else
2929
        {
2930
          addr = XEXP (home, 0);
2931
 
2932
          letter = decl_function_context (decl) ? 'V' : 'S';
2933
 
2934
          /* Some ports can transform a symbol ref into a label ref,
2935
             because the symbol ref is too far away and has to be
2936
             dumped into a constant pool.  Alternatively, the symbol
2937
             in the constant pool might be referenced by a different
2938
             symbol.  */
2939
          if (GET_CODE (addr) == SYMBOL_REF
2940
              && CONSTANT_POOL_ADDRESS_P (addr))
2941
            {
2942
              bool marked;
2943
              rtx tmp = get_pool_constant_mark (addr, &marked);
2944
 
2945
              if (GET_CODE (tmp) == SYMBOL_REF)
2946
                {
2947
                  addr = tmp;
2948
                  if (CONSTANT_POOL_ADDRESS_P (addr))
2949
                    get_pool_constant_mark (addr, &marked);
2950
                  else
2951
                    marked = true;
2952
                }
2953
              else if (GET_CODE (tmp) == LABEL_REF)
2954
                {
2955
                  addr = tmp;
2956
                  marked = true;
2957
                }
2958
 
2959
              /* If all references to the constant pool were optimized
2960
                 out, we just ignore the symbol.  */
2961
              if (!marked)
2962
                return 0;
2963
            }
2964
 
2965
          /* This should be the same condition as in assemble_variable, but
2966
             we don't have access to dont_output_data here.  So, instead,
2967
             we rely on the fact that error_mark_node initializers always
2968
             end up in bss for C++ and never end up in bss for C.  */
2969
          if (DECL_INITIAL (decl) == 0
2970
              || (!strcmp (lang_hooks.name, "GNU C++")
2971
                  && DECL_INITIAL (decl) == error_mark_node))
2972
            {
2973
              int offs;
2974
              code = N_LCSYM;
2975
              if (NULL != dbxout_common_check (decl, &offs))
2976
                {
2977
                  addr = 0;
2978
                  number = offs;
2979
                  letter = 'V';
2980
                  code = N_GSYM;
2981
                }
2982
            }
2983
          else if (DECL_IN_TEXT_SECTION (decl))
2984
            /* This is not quite right, but it's the closest
2985
               of all the codes that Unix defines.  */
2986
            code = DBX_STATIC_CONST_VAR_CODE;
2987
          else
2988
            {
2989
              /* Ultrix `as' seems to need this.  */
2990
#ifdef DBX_STATIC_STAB_DATA_SECTION
2991
              switch_to_section (data_section);
2992
#endif
2993
              code = N_STSYM;
2994
            }
2995
        }
2996
    }
2997
  else if (regno >= 0)
2998
    {
2999
      letter = 'r';
3000
      code = N_RSYM;
3001
      number = DBX_REGISTER_NUMBER (regno);
3002
    }
3003
  else if (MEM_P (home)
3004
           && (MEM_P (XEXP (home, 0))
3005
               || (REG_P (XEXP (home, 0))
3006
                   && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
3007
                   && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
3008
#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3009
                   && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
3010
#endif
3011
                   )))
3012
    /* If the value is indirect by memory or by a register
3013
       that isn't the frame pointer
3014
       then it means the object is variable-sized and address through
3015
       that register or stack slot.  DBX has no way to represent this
3016
       so all we can do is output the variable as a pointer.
3017
       If it's not a parameter, ignore it.  */
3018
    {
3019
      if (REG_P (XEXP (home, 0)))
3020
        {
3021
          letter = 'r';
3022
          code = N_RSYM;
3023
          if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
3024
            return 0;
3025
          number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
3026
        }
3027
      else
3028
        {
3029
          code = N_LSYM;
3030
          /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3031
             We want the value of that CONST_INT.  */
3032
          number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
3033
        }
3034
 
3035
      /* Effectively do build_pointer_type, but don't cache this type,
3036
         since it might be temporary whereas the type it points to
3037
         might have been saved for inlining.  */
3038
      /* Don't use REFERENCE_TYPE because dbx can't handle that.  */
3039
      type = make_node (POINTER_TYPE);
3040
      TREE_TYPE (type) = TREE_TYPE (decl);
3041
    }
3042
  else if (MEM_P (home)
3043
           && REG_P (XEXP (home, 0)))
3044
    {
3045
      code = N_LSYM;
3046
      number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3047
    }
3048
  else if (MEM_P (home)
3049
           && GET_CODE (XEXP (home, 0)) == PLUS
3050
           && CONST_INT_P (XEXP (XEXP (home, 0), 1)))
3051
    {
3052
      code = N_LSYM;
3053
      /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3054
         We want the value of that CONST_INT.  */
3055
      number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3056
    }
3057
  else if (MEM_P (home)
3058
           && GET_CODE (XEXP (home, 0)) == CONST)
3059
    {
3060
      /* Handle an obscure case which can arise when optimizing and
3061
         when there are few available registers.  (This is *always*
3062
         the case for i386/i486 targets).  The RTL looks like
3063
         (MEM (CONST ...)) even though this variable is a local `auto'
3064
         or a local `register' variable.  In effect, what has happened
3065
         is that the reload pass has seen that all assignments and
3066
         references for one such a local variable can be replaced by
3067
         equivalent assignments and references to some static storage
3068
         variable, thereby avoiding the need for a register.  In such
3069
         cases we're forced to lie to debuggers and tell them that
3070
         this variable was itself `static'.  */
3071
      int offs;
3072
      code = N_LCSYM;
3073
      letter = 'V';
3074
      if (NULL == dbxout_common_check (decl, &offs))
3075
        addr = XEXP (XEXP (home, 0), 0);
3076
      else
3077
        {
3078
          addr = 0;
3079
          number = offs;
3080
          code = N_GSYM;
3081
        }
3082
    }
3083
  else if (GET_CODE (home) == CONCAT)
3084
    {
3085
      tree subtype;
3086
 
3087
      /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3088
         for example), then there is no easy way to figure out
3089
         what SUBTYPE should be.  So, we give up.  */
3090
      if (TREE_CODE (type) != COMPLEX_TYPE)
3091
        return 0;
3092
 
3093
      subtype = TREE_TYPE (type);
3094
 
3095
      /* If the variable's storage is in two parts,
3096
         output each as a separate stab with a modified name.  */
3097
      if (WORDS_BIG_ENDIAN)
3098
        dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
3099
      else
3100
        dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
3101
 
3102
      if (WORDS_BIG_ENDIAN)
3103
        dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
3104
      else
3105
        dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
3106
      return 1;
3107
    }
3108
  else
3109
    /* Address might be a MEM, when DECL is a variable-sized object.
3110
       Or it might be const0_rtx, meaning previous passes
3111
       want us to ignore this variable.  */
3112
    return 0;
3113
 
3114
  /* Ok, start a symtab entry and output the variable name.  */
3115
  emit_pending_bincls_if_required ();
3116
  FORCE_TEXT;
3117
 
3118
#ifdef DBX_STATIC_BLOCK_START
3119
  DBX_STATIC_BLOCK_START (asm_out_file, code);
3120
#endif
3121
 
3122
  dbxout_begin_complex_stabs_noforcetext ();
3123
  dbxout_symbol_name (decl, suffix, letter);
3124
  dbxout_type (type, 0);
3125
  dbxout_finish_complex_stabs (decl, code, addr, 0, number);
3126
 
3127
#ifdef DBX_STATIC_BLOCK_END
3128
  DBX_STATIC_BLOCK_END (asm_out_file, code);
3129
#endif
3130
  return 1;
3131
}
3132
 
3133
/* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3134
   Then output LETTER to indicate the kind of location the symbol has.  */
3135
 
3136
static void
3137
dbxout_symbol_name (tree decl, const char *suffix, int letter)
3138
{
3139
  tree name;
3140
 
3141
  if (DECL_CONTEXT (decl)
3142
      && (TYPE_P (DECL_CONTEXT (decl))
3143
          || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
3144
    /* One slight hitch: if this is a VAR_DECL which is a class member
3145
       or a namespace member, we must put out the mangled name instead of the
3146
       DECL_NAME.  Note also that static member (variable) names DO NOT begin
3147
       with underscores in .stabs directives.  */
3148
    name = DECL_ASSEMBLER_NAME (decl);
3149
  else
3150
    /* ...but if we're function-local, we don't want to include the junk
3151
       added by ASM_FORMAT_PRIVATE_NAME.  */
3152
    name = DECL_NAME (decl);
3153
 
3154
  if (name)
3155
    stabstr_I (name);
3156
  else
3157
    stabstr_S ("(anon)");
3158
 
3159
  if (suffix)
3160
    stabstr_S (suffix);
3161
  stabstr_C (':');
3162
  if (letter)
3163
    stabstr_C (letter);
3164
}
3165
 
3166
 
3167
/* Output the common block name for DECL in a stabs.
3168
 
3169
   Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3170
   around each group of symbols in the same .comm area.  The N_GSYM stabs
3171
   that are emitted only contain the offset in the common area.  This routine
3172
   emits the N_BCOMM and N_ECOMM stabs.  */
3173
 
3174
static void
3175
dbxout_common_name (tree decl, const char *name, stab_code_type op)
3176
{
3177
  dbxout_begin_complex_stabs ();
3178
  stabstr_S (name);
3179
  dbxout_finish_complex_stabs (decl, op, NULL_RTX, NULL, 0);
3180
}
3181
 
3182
/* Check decl to determine whether it is a VAR_DECL destined for storage in a
3183
   common area.  If it is, the return value will be a non-null string giving
3184
   the name of the common storage block it will go into.  If non-null, the
3185
   value is the offset into the common block for that symbol's storage.  */
3186
 
3187
static const char *
3188
dbxout_common_check (tree decl, int *value)
3189
{
3190
  rtx home;
3191
  rtx sym_addr;
3192
  const char *name = NULL;
3193
 
3194
  /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3195
     it does not have a value (the offset into the common area), or if it
3196
     is thread local (as opposed to global) then it isn't common, and shouldn't
3197
     be handled as such.
3198
 
3199
     ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3200
     for thread-local symbols.  Can be handled via same mechanism as used
3201
     in dwarf2out.c.  */
3202
  if (TREE_CODE (decl) != VAR_DECL
3203
      || !TREE_STATIC(decl)
3204
      || !DECL_HAS_VALUE_EXPR_P(decl)
3205
      || DECL_THREAD_LOCAL_P (decl)
3206
      || !is_fortran ())
3207
    return NULL;
3208
 
3209
  home = DECL_RTL (decl);
3210
  if (home == NULL_RTX || GET_CODE (home) != MEM)
3211
    return NULL;
3212
 
3213
  sym_addr = dbxout_expand_expr (DECL_VALUE_EXPR (decl));
3214
  if (sym_addr == NULL_RTX || GET_CODE (sym_addr) != MEM)
3215
    return NULL;
3216
 
3217
  sym_addr = XEXP (sym_addr, 0);
3218
  if (GET_CODE (sym_addr) == CONST)
3219
    sym_addr = XEXP (sym_addr, 0);
3220
  if ((GET_CODE (sym_addr) == SYMBOL_REF || GET_CODE (sym_addr) == PLUS)
3221
      && DECL_INITIAL (decl) == 0)
3222
    {
3223
 
3224
      /* We have a sym that will go into a common area, meaning that it
3225
         will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3226
 
3227
         Determine name of common area this symbol will be an offset into,
3228
         and offset into that area.  Also retrieve the decl for the area
3229
         that the symbol is offset into.  */
3230
      tree cdecl = NULL;
3231
 
3232
      switch (GET_CODE (sym_addr))
3233
        {
3234
        case PLUS:
3235
          if (CONST_INT_P (XEXP (sym_addr, 0)))
3236
            {
3237
              name =
3238
                targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 1), 0));
3239
              *value = INTVAL (XEXP (sym_addr, 0));
3240
              cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
3241
            }
3242
          else
3243
            {
3244
              name =
3245
                targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 0), 0));
3246
              *value = INTVAL (XEXP (sym_addr, 1));
3247
              cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0));
3248
            }
3249
          break;
3250
 
3251
        case SYMBOL_REF:
3252
          name = targetm.strip_name_encoding(XSTR (sym_addr, 0));
3253
          *value = 0;
3254
          cdecl = SYMBOL_REF_DECL (sym_addr);
3255
          break;
3256
 
3257
        default:
3258
          error ("common symbol debug info is not structured as "
3259
                 "symbol+offset");
3260
        }
3261
 
3262
      /* Check area common symbol is offset into.  If this is not public, then
3263
         it is not a symbol in a common block.  It must be a .lcomm symbol, not
3264
         a .comm symbol.  */
3265
      if (cdecl == NULL || !TREE_PUBLIC(cdecl))
3266
        name = NULL;
3267
    }
3268
  else
3269
    name = NULL;
3270
 
3271
  return name;
3272
}
3273
 
3274
/* Output definitions of all the decls in a chain. Return nonzero if
3275
   anything was output */
3276
 
3277
int
3278
dbxout_syms (tree syms)
3279
{
3280
  int result = 0;
3281
  const char *comm_prev = NULL;
3282
  tree syms_prev = NULL;
3283
 
3284
  while (syms)
3285
    {
3286
      int temp, copen, cclos;
3287
      const char *comm_new;
3288
 
3289
      /* Check for common symbol, and then progression into a new/different
3290
         block of common symbols.  Emit closing/opening common bracket if
3291
         necessary.  */
3292
      comm_new = dbxout_common_check (syms, &temp);
3293
      copen = comm_new != NULL
3294
              && (comm_prev == NULL || strcmp (comm_new, comm_prev));
3295
      cclos = comm_prev != NULL
3296
              && (comm_new == NULL || strcmp (comm_new, comm_prev));
3297
      if (cclos)
3298
        dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3299
      if (copen)
3300
        {
3301
          dbxout_common_name (syms, comm_new, N_BCOMM);
3302
          syms_prev = syms;
3303
        }
3304
      comm_prev = comm_new;
3305
 
3306
      result += dbxout_symbol (syms, 1);
3307
      syms = TREE_CHAIN (syms);
3308
    }
3309
 
3310
  if (comm_prev != NULL)
3311
    dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3312
 
3313
  return result;
3314
}
3315
 
3316
/* The following two functions output definitions of function parameters.
3317
   Each parameter gets a definition locating it in the parameter list.
3318
   Each parameter that is a register variable gets a second definition
3319
   locating it in the register.
3320
 
3321
   Printing or argument lists in gdb uses the definitions that
3322
   locate in the parameter list.  But reference to the variable in
3323
   expressions uses preferentially the definition as a register.  */
3324
 
3325
/* Output definitions, referring to storage in the parmlist,
3326
   of all the parms in PARMS, which is a chain of PARM_DECL nodes.  */
3327
 
3328
void
3329
dbxout_parms (tree parms)
3330
{
3331
  ++debug_nesting;
3332
  emit_pending_bincls_if_required ();
3333
 
3334
  for (; parms; parms = TREE_CHAIN (parms))
3335
    if (DECL_NAME (parms)
3336
        && TREE_TYPE (parms) != error_mark_node
3337
        && DECL_RTL_SET_P (parms)
3338
        && DECL_INCOMING_RTL (parms))
3339
      {
3340
        tree eff_type;
3341
        char letter;
3342
        stab_code_type code;
3343
        int number;
3344
 
3345
        /* Perform any necessary register eliminations on the parameter's rtl,
3346
           so that the debugging output will be accurate.  */
3347
        DECL_INCOMING_RTL (parms)
3348
          = eliminate_regs (DECL_INCOMING_RTL (parms), VOIDmode, NULL_RTX);
3349
        SET_DECL_RTL (parms,
3350
                      eliminate_regs (DECL_RTL (parms), VOIDmode, NULL_RTX));
3351
#ifdef LEAF_REG_REMAP
3352
        if (current_function_uses_only_leaf_regs)
3353
          {
3354
            leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
3355
            leaf_renumber_regs_insn (DECL_RTL (parms));
3356
          }
3357
#endif
3358
 
3359
        if (PARM_PASSED_IN_MEMORY (parms))
3360
          {
3361
            rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
3362
 
3363
            /* ??? Here we assume that the parm address is indexed
3364
               off the frame pointer or arg pointer.
3365
               If that is not true, we produce meaningless results,
3366
               but do not crash.  */
3367
            if (GET_CODE (inrtl) == PLUS
3368
                && CONST_INT_P (XEXP (inrtl, 1)))
3369
              number = INTVAL (XEXP (inrtl, 1));
3370
            else
3371
              number = 0;
3372
 
3373
            code = N_PSYM;
3374
            number = DEBUGGER_ARG_OFFSET (number, inrtl);
3375
            letter = 'p';
3376
 
3377
            /* It is quite tempting to use TREE_TYPE (parms) instead
3378
               of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3379
               reports the actual type of the parameter, rather than
3380
               the promoted type.  This certainly makes GDB's life
3381
               easier, at least for some ports.  The change is a bad
3382
               idea however, since GDB expects to be able access the
3383
               type without performing any conversions.  So for
3384
               example, if we were passing a float to an unprototyped
3385
               function, gcc will store a double on the stack, but if
3386
               we emit a stab saying the type is a float, then gdb
3387
               will only read in a single value, and this will produce
3388
               an erroneous value.  */
3389
            eff_type = DECL_ARG_TYPE (parms);
3390
          }
3391
        else if (REG_P (DECL_RTL (parms)))
3392
          {
3393
            rtx best_rtl;
3394
 
3395
            /* Parm passed in registers and lives in registers or nowhere.  */
3396
            code = DBX_REGPARM_STABS_CODE;
3397
            letter = DBX_REGPARM_STABS_LETTER;
3398
 
3399
            /* For parms passed in registers, it is better to use the
3400
               declared type of the variable, not the type it arrived in.  */
3401
            eff_type = TREE_TYPE (parms);
3402
 
3403
            /* If parm lives in a register, use that register; pretend
3404
               the parm was passed there.  It would be more consistent
3405
               to describe the register where the parm was passed, but
3406
               in practice that register usually holds something else.
3407
               If the parm lives nowhere, use the register where it
3408
               was passed.  */
3409
            if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3410
              best_rtl = DECL_RTL (parms);
3411
            else if (GET_CODE (DECL_INCOMING_RTL (parms)) == PARALLEL)
3412
              best_rtl = XEXP (XVECEXP (DECL_INCOMING_RTL (parms), 0, 0), 0);
3413
            else
3414
              best_rtl = DECL_INCOMING_RTL (parms);
3415
 
3416
            number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
3417
          }
3418
        else if (MEM_P (DECL_RTL (parms))
3419
                 && REG_P (XEXP (DECL_RTL (parms), 0))
3420
                 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
3421
                 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
3422
#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3423
                 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
3424
#endif
3425
                 )
3426
          {
3427
            /* Parm was passed via invisible reference.
3428
               That is, its address was passed in a register.
3429
               Output it as if it lived in that register.
3430
               The debugger will know from the type
3431
               that it was actually passed by invisible reference.  */
3432
 
3433
            code = DBX_REGPARM_STABS_CODE;
3434
 
3435
            /* GDB likes this marked with a special letter.  */
3436
            letter = (use_gnu_debug_info_extensions
3437
                      ? 'a' : DBX_REGPARM_STABS_LETTER);
3438
            eff_type = TREE_TYPE (parms);
3439
 
3440
            /* DECL_RTL looks like (MEM (REG...).  Get the register number.
3441
               If it is an unallocated pseudo-reg, then use the register where
3442
               it was passed instead.
3443
               ??? Why is DBX_REGISTER_NUMBER not used here?  */
3444
 
3445
            if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
3446
              number = REGNO (XEXP (DECL_RTL (parms), 0));
3447
            else
3448
              number = REGNO (DECL_INCOMING_RTL (parms));
3449
          }
3450
        else if (MEM_P (DECL_RTL (parms))
3451
                 && MEM_P (XEXP (DECL_RTL (parms), 0)))
3452
          {
3453
            /* Parm was passed via invisible reference, with the reference
3454
               living on the stack.  DECL_RTL looks like
3455
               (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3456
               could look like (MEM (MEM (REG))).  */
3457
 
3458
            code = N_PSYM;
3459
            letter = 'v';
3460
            eff_type = TREE_TYPE (parms);
3461
 
3462
            if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
3463
              number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
3464
            else
3465
              number = 0;
3466
 
3467
            number = DEBUGGER_ARG_OFFSET (number,
3468
                                          XEXP (XEXP (DECL_RTL (parms), 0), 0));
3469
          }
3470
        else if (MEM_P (DECL_RTL (parms))
3471
                 && XEXP (DECL_RTL (parms), 0) != const0_rtx
3472
                 /* ??? A constant address for a parm can happen
3473
                    when the reg it lives in is equiv to a constant in memory.
3474
                    Should make this not happen, after 2.4.  */
3475
                 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
3476
          {
3477
            /* Parm was passed in registers but lives on the stack.  */
3478
 
3479
            code = N_PSYM;
3480
            letter = 'p';
3481
            eff_type = TREE_TYPE (parms);
3482
 
3483
            /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3484
               in which case we want the value of that CONST_INT,
3485
               or (MEM (REG ...)),
3486
               in which case we use a value of zero.  */
3487
            if (!REG_P (XEXP (DECL_RTL (parms), 0)))
3488
              number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
3489
            else
3490
              number = 0;
3491
 
3492
            /* Make a big endian correction if the mode of the type of the
3493
               parameter is not the same as the mode of the rtl.  */
3494
            if (BYTES_BIG_ENDIAN
3495
                && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3496
                && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3497
              number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3498
                         - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
3499
          }
3500
        else
3501
          /* ??? We don't know how to represent this argument.  */
3502
          continue;
3503
 
3504
        dbxout_begin_complex_stabs ();
3505
 
3506
        if (DECL_NAME (parms))
3507
          {
3508
            stabstr_I (DECL_NAME (parms));
3509
            stabstr_C (':');
3510
          }
3511
        else
3512
          stabstr_S ("(anon):");
3513
        stabstr_C (letter);
3514
        dbxout_type (eff_type, 0);
3515
        dbxout_finish_complex_stabs (parms, code, 0, 0, number);
3516
      }
3517
  DBXOUT_DECR_NESTING;
3518
}
3519
 
3520
/* Output definitions for the places where parms live during the function,
3521
   when different from where they were passed, when the parms were passed
3522
   in memory.
3523
 
3524
   It is not useful to do this for parms passed in registers
3525
   that live during the function in different registers, because it is
3526
   impossible to look in the passed register for the passed value,
3527
   so we use the within-the-function register to begin with.
3528
 
3529
   PARMS is a chain of PARM_DECL nodes.  */
3530
 
3531
void
3532
dbxout_reg_parms (tree parms)
3533
{
3534
  ++debug_nesting;
3535
 
3536
  for (; parms; parms = TREE_CHAIN (parms))
3537
    if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3538
      {
3539
        /* Report parms that live in registers during the function
3540
           but were passed in memory.  */
3541
        if (REG_P (DECL_RTL (parms))
3542
            && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3543
          dbxout_symbol_location (parms, TREE_TYPE (parms),
3544
                                  0, DECL_RTL (parms));
3545
        else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3546
          dbxout_symbol_location (parms, TREE_TYPE (parms),
3547
                                  0, DECL_RTL (parms));
3548
        /* Report parms that live in memory but not where they were passed.  */
3549
        else if (MEM_P (DECL_RTL (parms))
3550
                 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3551
          dbxout_symbol_location (parms, TREE_TYPE (parms),
3552
                                  0, DECL_RTL (parms));
3553
      }
3554
  DBXOUT_DECR_NESTING;
3555
}
3556
 
3557
/* Given a chain of ..._TYPE nodes (as come in a parameter list),
3558
   output definitions of those names, in raw form */
3559
 
3560
static void
3561
dbxout_args (tree args)
3562
{
3563
  while (args)
3564
    {
3565
      stabstr_C (',');
3566
      dbxout_type (TREE_VALUE (args), 0);
3567
      args = TREE_CHAIN (args);
3568
    }
3569
}
3570
 
3571
#if defined (DBX_DEBUGGING_INFO)
3572
 
3573
/* Subroutine of dbxout_block.  Emit an N_LBRAC stab referencing LABEL.
3574
   BEGIN_LABEL is the name of the beginning of the function, which may
3575
   be required.  */
3576
static void
3577
dbx_output_lbrac (const char *label,
3578
                  const char *begin_label ATTRIBUTE_UNUSED)
3579
{
3580
  dbxout_begin_stabn (N_LBRAC);
3581
  if (DBX_BLOCKS_FUNCTION_RELATIVE)
3582
    dbxout_stab_value_label_diff (label, begin_label);
3583
  else
3584
    dbxout_stab_value_label (label);
3585
}
3586
 
3587
/* Subroutine of dbxout_block.  Emit an N_RBRAC stab referencing LABEL.
3588
   BEGIN_LABEL is the name of the beginning of the function, which may
3589
   be required.  */
3590
static void
3591
dbx_output_rbrac (const char *label,
3592
                  const char *begin_label ATTRIBUTE_UNUSED)
3593
{
3594
  dbxout_begin_stabn (N_RBRAC);
3595
  if (DBX_BLOCKS_FUNCTION_RELATIVE)
3596
    dbxout_stab_value_label_diff (label, begin_label);
3597
  else
3598
    dbxout_stab_value_label (label);
3599
}
3600
 
3601
/* Output everything about a symbol block (a BLOCK node
3602
   that represents a scope level),
3603
   including recursive output of contained blocks.
3604
 
3605
   BLOCK is the BLOCK node.
3606
   DEPTH is its depth within containing symbol blocks.
3607
   ARGS is usually zero; but for the outermost block of the
3608
   body of a function, it is a chain of PARM_DECLs for the function parameters.
3609
   We output definitions of all the register parms
3610
   as if they were local variables of that block.
3611
 
3612
   If -g1 was used, we count blocks just the same, but output nothing
3613
   except for the outermost block.
3614
 
3615
   Actually, BLOCK may be several blocks chained together.
3616
   We handle them all in sequence.  */
3617
 
3618
static void
3619
dbxout_block (tree block, int depth, tree args)
3620
{
3621
  char begin_label[20];
3622
  /* Reference current function start using LFBB.  */
3623
  ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
3624
 
3625
  while (block)
3626
    {
3627
      /* Ignore blocks never expanded or otherwise marked as real.  */
3628
      if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3629
        {
3630
          int did_output;
3631
          int blocknum = BLOCK_NUMBER (block);
3632
 
3633
          /* In dbx format, the syms of a block come before the N_LBRAC.
3634
             If nothing is output, we don't need the N_LBRAC, either.  */
3635
          did_output = 0;
3636
          if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3637
            did_output = dbxout_syms (BLOCK_VARS (block));
3638
          if (args)
3639
            dbxout_reg_parms (args);
3640
 
3641
          /* Now output an N_LBRAC symbol to represent the beginning of
3642
             the block.  Use the block's tree-walk order to generate
3643
             the assembler symbols LBBn and LBEn
3644
             that final will define around the code in this block.  */
3645
          if (did_output)
3646
            {
3647
              char buf[20];
3648
              const char *scope_start;
3649
 
3650
              if (depth == 0)
3651
                /* The outermost block doesn't get LBB labels; use
3652
                   the LFBB local symbol emitted by dbxout_begin_prologue.  */
3653
                scope_start = begin_label;
3654
              else
3655
                {
3656
                  ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3657
                  scope_start = buf;
3658
                }
3659
 
3660
              dbx_output_lbrac (scope_start, begin_label);
3661
            }
3662
 
3663
          /* Output the subblocks.  */
3664
          dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3665
 
3666
          /* Refer to the marker for the end of the block.  */
3667
          if (did_output)
3668
            {
3669
              char buf[100];
3670
              if (depth == 0)
3671
                /* The outermost block doesn't get LBE labels;
3672
                   use the "scope" label which will be emitted
3673
                   by dbxout_function_end.  */
3674
                ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
3675
              else
3676
                ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3677
 
3678
              dbx_output_rbrac (buf, begin_label);
3679
            }
3680
        }
3681
      block = BLOCK_CHAIN (block);
3682
    }
3683
}
3684
 
3685
/* Output the information about a function and its arguments and result.
3686
   Usually this follows the function's code,
3687
   but on some systems, it comes before.  */
3688
 
3689
static void
3690
dbxout_begin_function (tree decl)
3691
{
3692
  int saved_tree_used1;
3693
 
3694
  saved_tree_used1 = TREE_USED (decl);
3695
  TREE_USED (decl) = 1;
3696
  if (DECL_NAME (DECL_RESULT (decl)) != 0)
3697
    {
3698
      int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3699
      TREE_USED (DECL_RESULT (decl)) = 1;
3700
      dbxout_symbol (decl, 0);
3701
      TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3702
    }
3703
  else
3704
    dbxout_symbol (decl, 0);
3705
  TREE_USED (decl) = saved_tree_used1;
3706
 
3707
  dbxout_parms (DECL_ARGUMENTS (decl));
3708
  if (DECL_NAME (DECL_RESULT (decl)) != 0)
3709
    dbxout_symbol (DECL_RESULT (decl), 1);
3710
}
3711
#endif /* DBX_DEBUGGING_INFO */
3712
 
3713
#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3714
 
3715
#include "gt-dbxout.h"

powered by: WebSVN 2.1.0

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