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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [dbxout.c] - Blame information for rev 193

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

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

powered by: WebSVN 2.1.0

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