|
0
|
1 /* Output sdb-format symbol table information from GNU compiler.
|
|
|
2 Copyright (C) 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
|
|
3 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
|
|
|
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 /* mike@tredysvr.Tredydev.Unisys.COM says:
|
|
|
23 I modified the struct.c example and have a nm of a .o resulting from the
|
|
|
24 AT&T C compiler. From the example below I would conclude the following:
|
|
|
25
|
|
|
26 1. All .defs from structures are emitted as scanned. The example below
|
|
|
27 clearly shows the symbol table entries for BoxRec2 are after the first
|
|
|
28 function.
|
|
|
29
|
|
|
30 2. All functions and their locals (including statics) are emitted as scanned.
|
|
|
31
|
|
|
32 3. All nested unnamed union and structure .defs must be emitted before
|
|
|
33 the structure in which they are nested. The AT&T assembler is a
|
|
|
34 one pass beast as far as symbolics are concerned.
|
|
|
35
|
|
|
36 4. All structure .defs are emitted before the typedefs that refer to them.
|
|
|
37
|
|
|
38 5. All top level static and external variable definitions are moved to the
|
|
|
39 end of file with all top level statics occurring first before externs.
|
|
|
40
|
|
|
41 6. All undefined references are at the end of the file.
|
|
|
42 */
|
|
|
43
|
|
|
44 #include "config.h"
|
|
|
45 #include "system.h"
|
|
|
46 #include "coretypes.h"
|
|
|
47 #include "tm.h"
|
|
|
48 #include "debug.h"
|
|
|
49 #include "tree.h"
|
|
|
50 #include "ggc.h"
|
|
|
51 #include "varray.h"
|
|
|
52
|
|
|
53 static GTY(()) tree anonymous_types;
|
|
|
54
|
|
|
55 /* Counter to generate unique "names" for nameless struct members. */
|
|
|
56
|
|
|
57 static GTY(()) int unnamed_struct_number;
|
|
|
58
|
|
|
59 /* Declarations whose debug info was deferred till end of compilation. */
|
|
|
60
|
|
|
61 static GTY(()) varray_type deferred_global_decls;
|
|
|
62
|
|
|
63 /* The C front end may call sdbout_symbol before sdbout_init runs.
|
|
|
64 We save all such decls in this list and output them when we get
|
|
|
65 to sdbout_init. */
|
|
|
66
|
|
|
67 static GTY(()) tree preinit_symbols;
|
|
|
68 static GTY(()) bool sdbout_initialized;
|
|
|
69
|
|
|
70 #ifdef SDB_DEBUGGING_INFO
|
|
|
71
|
|
|
72 #include "rtl.h"
|
|
|
73 #include "regs.h"
|
|
|
74 #include "flags.h"
|
|
|
75 #include "insn-config.h"
|
|
|
76 #include "reload.h"
|
|
|
77 #include "output.h"
|
|
|
78 #include "toplev.h"
|
|
|
79 #include "tm_p.h"
|
|
|
80 #include "gsyms.h"
|
|
|
81 #include "langhooks.h"
|
|
|
82 #include "target.h"
|
|
|
83
|
|
|
84 /* 1 if PARM is passed to this function in memory. */
|
|
|
85
|
|
|
86 #define PARM_PASSED_IN_MEMORY(PARM) \
|
|
|
87 (MEM_P (DECL_INCOMING_RTL (PARM)))
|
|
|
88
|
|
|
89 /* A C expression for the integer offset value of an automatic variable
|
|
|
90 (C_AUTO) having address X (an RTX). */
|
|
|
91 #ifndef DEBUGGER_AUTO_OFFSET
|
|
|
92 #define DEBUGGER_AUTO_OFFSET(X) \
|
|
|
93 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
|
|
|
94 #endif
|
|
|
95
|
|
|
96 /* A C expression for the integer offset value of an argument (C_ARG)
|
|
|
97 having address X (an RTX). The nominal offset is OFFSET. */
|
|
|
98 #ifndef DEBUGGER_ARG_OFFSET
|
|
|
99 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
|
|
|
100 #endif
|
|
|
101
|
|
|
102 /* Line number of beginning of current function, minus one.
|
|
|
103 Negative means not in a function or not using sdb. */
|
|
|
104
|
|
|
105 int sdb_begin_function_line = -1;
|
|
|
106
|
|
|
107
|
|
|
108 extern FILE *asm_out_file;
|
|
|
109
|
|
|
110 extern tree current_function_decl;
|
|
|
111
|
|
|
112 #include "sdbout.h"
|
|
|
113
|
|
|
114 static void sdbout_init (const char *);
|
|
|
115 static void sdbout_finish (const char *);
|
|
|
116 static void sdbout_start_source_file (unsigned int, const char *);
|
|
|
117 static void sdbout_end_source_file (unsigned int);
|
|
|
118 static void sdbout_begin_block (unsigned int, unsigned int);
|
|
|
119 static void sdbout_end_block (unsigned int, unsigned int);
|
|
|
120 static void sdbout_source_line (unsigned int, const char *);
|
|
|
121 static void sdbout_end_epilogue (unsigned int, const char *);
|
|
|
122 static void sdbout_global_decl (tree);
|
|
|
123 #ifndef MIPS_DEBUGGING_INFO
|
|
|
124 static void sdbout_begin_prologue (unsigned int, const char *);
|
|
|
125 #endif
|
|
|
126 static void sdbout_end_prologue (unsigned int, const char *);
|
|
|
127 static void sdbout_begin_function (tree);
|
|
|
128 static void sdbout_end_function (unsigned int);
|
|
|
129 static void sdbout_toplevel_data (tree);
|
|
|
130 static void sdbout_label (rtx);
|
|
|
131 static char *gen_fake_label (void);
|
|
|
132 static int plain_type (tree);
|
|
|
133 static int template_name_p (tree);
|
|
|
134 static void sdbout_record_type_name (tree);
|
|
|
135 static int plain_type_1 (tree, int);
|
|
|
136 static void sdbout_block (tree);
|
|
|
137 static void sdbout_syms (tree);
|
|
|
138 #ifdef SDB_ALLOW_FORWARD_REFERENCES
|
|
|
139 static void sdbout_queue_anonymous_type (tree);
|
|
|
140 static void sdbout_dequeue_anonymous_types (void);
|
|
|
141 #endif
|
|
|
142 static void sdbout_type (tree);
|
|
|
143 static void sdbout_field_types (tree);
|
|
|
144 static void sdbout_one_type (tree);
|
|
|
145 static void sdbout_parms (tree);
|
|
|
146 static void sdbout_reg_parms (tree);
|
|
|
147 static void sdbout_global_decl (tree);
|
|
|
148
|
|
|
149 /* Random macros describing parts of SDB data. */
|
|
|
150
|
|
|
151 /* Default value of delimiter is ";". */
|
|
|
152 #ifndef SDB_DELIM
|
|
|
153 #define SDB_DELIM ";"
|
|
|
154 #endif
|
|
|
155
|
|
|
156 /* Maximum number of dimensions the assembler will allow. */
|
|
|
157 #ifndef SDB_MAX_DIM
|
|
|
158 #define SDB_MAX_DIM 4
|
|
|
159 #endif
|
|
|
160
|
|
|
161 #ifndef PUT_SDB_SCL
|
|
|
162 #define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
|
|
|
163 #endif
|
|
|
164
|
|
|
165 #ifndef PUT_SDB_INT_VAL
|
|
|
166 #define PUT_SDB_INT_VAL(a) \
|
|
|
167 do { \
|
|
|
168 fprintf (asm_out_file, "\t.val\t" HOST_WIDE_INT_PRINT_DEC "%s", \
|
|
|
169 (HOST_WIDE_INT) (a), SDB_DELIM); \
|
|
|
170 } while (0)
|
|
|
171
|
|
|
172 #endif
|
|
|
173
|
|
|
174 #ifndef PUT_SDB_VAL
|
|
|
175 #define PUT_SDB_VAL(a) \
|
|
|
176 ( fputs ("\t.val\t", asm_out_file), \
|
|
|
177 output_addr_const (asm_out_file, (a)), \
|
|
|
178 fprintf (asm_out_file, SDB_DELIM))
|
|
|
179 #endif
|
|
|
180
|
|
|
181 #ifndef PUT_SDB_DEF
|
|
|
182 #define PUT_SDB_DEF(a) \
|
|
|
183 do { fprintf (asm_out_file, "\t.def\t"); \
|
|
|
184 assemble_name (asm_out_file, a); \
|
|
|
185 fprintf (asm_out_file, SDB_DELIM); } while (0)
|
|
|
186 #endif
|
|
|
187
|
|
|
188 #ifndef PUT_SDB_PLAIN_DEF
|
|
|
189 #define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
|
|
|
190 #endif
|
|
|
191
|
|
|
192 #ifndef PUT_SDB_ENDEF
|
|
|
193 #define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
|
|
|
194 #endif
|
|
|
195
|
|
|
196 #ifndef PUT_SDB_TYPE
|
|
|
197 #define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
|
|
|
198 #endif
|
|
|
199
|
|
|
200 #ifndef PUT_SDB_SIZE
|
|
|
201 #define PUT_SDB_SIZE(a) \
|
|
|
202 do { \
|
|
|
203 fprintf (asm_out_file, "\t.size\t" HOST_WIDE_INT_PRINT_DEC "%s", \
|
|
|
204 (HOST_WIDE_INT) (a), SDB_DELIM); \
|
|
|
205 } while(0)
|
|
|
206 #endif
|
|
|
207
|
|
|
208 #ifndef PUT_SDB_START_DIM
|
|
|
209 #define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
|
|
|
210 #endif
|
|
|
211
|
|
|
212 #ifndef PUT_SDB_NEXT_DIM
|
|
|
213 #define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
|
|
|
214 #endif
|
|
|
215
|
|
|
216 #ifndef PUT_SDB_LAST_DIM
|
|
|
217 #define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
|
|
|
218 #endif
|
|
|
219
|
|
|
220 #ifndef PUT_SDB_TAG
|
|
|
221 #define PUT_SDB_TAG(a) \
|
|
|
222 do { fprintf (asm_out_file, "\t.tag\t"); \
|
|
|
223 assemble_name (asm_out_file, a); \
|
|
|
224 fprintf (asm_out_file, SDB_DELIM); } while (0)
|
|
|
225 #endif
|
|
|
226
|
|
|
227 #ifndef PUT_SDB_BLOCK_START
|
|
|
228 #define PUT_SDB_BLOCK_START(LINE) \
|
|
|
229 fprintf (asm_out_file, \
|
|
|
230 "\t.def\t.bb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
|
|
|
231 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
|
|
|
232 #endif
|
|
|
233
|
|
|
234 #ifndef PUT_SDB_BLOCK_END
|
|
|
235 #define PUT_SDB_BLOCK_END(LINE) \
|
|
|
236 fprintf (asm_out_file, \
|
|
|
237 "\t.def\t.eb%s\t.val\t.%s\t.scl\t100%s\t.line\t%d%s\t.endef\n", \
|
|
|
238 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
|
|
|
239 #endif
|
|
|
240
|
|
|
241 #ifndef PUT_SDB_FUNCTION_START
|
|
|
242 #define PUT_SDB_FUNCTION_START(LINE) \
|
|
|
243 fprintf (asm_out_file, \
|
|
|
244 "\t.def\t.bf%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
|
|
|
245 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
|
|
|
246 #endif
|
|
|
247
|
|
|
248 #ifndef PUT_SDB_FUNCTION_END
|
|
|
249 #define PUT_SDB_FUNCTION_END(LINE) \
|
|
|
250 fprintf (asm_out_file, \
|
|
|
251 "\t.def\t.ef%s\t.val\t.%s\t.scl\t101%s\t.line\t%d%s\t.endef\n", \
|
|
|
252 SDB_DELIM, SDB_DELIM, SDB_DELIM, (LINE), SDB_DELIM)
|
|
|
253 #endif
|
|
|
254
|
|
|
255 /* Return the sdb tag identifier string for TYPE
|
|
|
256 if TYPE has already been defined; otherwise return a null pointer. */
|
|
|
257
|
|
|
258 #define KNOWN_TYPE_TAG(type) TYPE_SYMTAB_POINTER (type)
|
|
|
259
|
|
|
260 /* Set the sdb tag identifier string for TYPE to NAME. */
|
|
|
261
|
|
|
262 #define SET_KNOWN_TYPE_TAG(TYPE, NAME) \
|
|
|
263 TYPE_SYMTAB_POINTER (TYPE) = (const char *)(NAME)
|
|
|
264
|
|
|
265 /* Return the name (a string) of the struct, union or enum tag
|
|
|
266 described by the TREE_LIST node LINK. This is 0 for an anonymous one. */
|
|
|
267
|
|
|
268 #define TAG_NAME(link) \
|
|
|
269 (((link) && TREE_PURPOSE ((link)) \
|
|
|
270 && IDENTIFIER_POINTER (TREE_PURPOSE ((link)))) \
|
|
|
271 ? IDENTIFIER_POINTER (TREE_PURPOSE ((link))) : (char *) 0)
|
|
|
272
|
|
|
273 /* Ensure we don't output a negative line number. */
|
|
|
274 #define MAKE_LINE_SAFE(line) \
|
|
|
275 if ((int) line <= sdb_begin_function_line) \
|
|
|
276 line = sdb_begin_function_line + 1
|
|
|
277
|
|
|
278 /* Perform linker optimization of merging header file definitions together
|
|
|
279 for targets with MIPS_DEBUGGING_INFO defined. This won't work without a
|
|
|
280 post 960826 version of GAS. Nothing breaks with earlier versions of GAS,
|
|
|
281 the optimization just won't be done. The native assembler already has the
|
|
|
282 necessary support. */
|
|
|
283
|
|
|
284 #ifdef MIPS_DEBUGGING_INFO
|
|
|
285
|
|
|
286 /* ECOFF linkers have an optimization that does the same kind of thing as
|
|
|
287 N_BINCL/E_INCL in stabs: eliminate duplicate debug information in the
|
|
|
288 executable. To achieve this, GCC must output a .file for each file
|
|
|
289 name change. */
|
|
|
290
|
|
|
291 /* This is a stack of input files. */
|
|
|
292
|
|
|
293 struct sdb_file
|
|
|
294 {
|
|
|
295 struct sdb_file *next;
|
|
|
296 const char *name;
|
|
|
297 };
|
|
|
298
|
|
|
299 /* This is the top of the stack. */
|
|
|
300
|
|
|
301 static struct sdb_file *current_file;
|
|
|
302
|
|
|
303 #endif /* MIPS_DEBUGGING_INFO */
|
|
|
304
|
|
|
305 /* The debug hooks structure. */
|
|
|
306 const struct gcc_debug_hooks sdb_debug_hooks =
|
|
|
307 {
|
|
|
308 sdbout_init, /* init */
|
|
|
309 sdbout_finish, /* finish */
|
|
36
|
310 debug_nothing_void, /* assembly_start */
|
|
0
|
311 debug_nothing_int_charstar, /* define */
|
|
|
312 debug_nothing_int_charstar, /* undef */
|
|
|
313 sdbout_start_source_file, /* start_source_file */
|
|
|
314 sdbout_end_source_file, /* end_source_file */
|
|
|
315 sdbout_begin_block, /* begin_block */
|
|
|
316 sdbout_end_block, /* end_block */
|
|
|
317 debug_true_const_tree, /* ignore_block */
|
|
|
318 sdbout_source_line, /* source_line */
|
|
|
319 #ifdef MIPS_DEBUGGING_INFO
|
|
|
320 /* Defer on MIPS systems so that parameter descriptions follow
|
|
|
321 function entry. */
|
|
|
322 debug_nothing_int_charstar, /* begin_prologue */
|
|
|
323 sdbout_end_prologue, /* end_prologue */
|
|
|
324 #else
|
|
|
325 sdbout_begin_prologue, /* begin_prologue */
|
|
|
326 debug_nothing_int_charstar, /* end_prologue */
|
|
|
327 #endif
|
|
|
328 sdbout_end_epilogue, /* end_epilogue */
|
|
|
329 sdbout_begin_function, /* begin_function */
|
|
|
330 sdbout_end_function, /* end_function */
|
|
|
331 debug_nothing_tree, /* function_decl */
|
|
|
332 sdbout_global_decl, /* global_decl */
|
|
|
333 sdbout_symbol, /* type_decl */
|
|
|
334 debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
|
|
|
335 debug_nothing_tree, /* deferred_inline_function */
|
|
|
336 debug_nothing_tree, /* outlining_inline_function */
|
|
|
337 sdbout_label, /* label */
|
|
|
338 debug_nothing_int, /* handle_pch */
|
|
|
339 debug_nothing_rtx, /* var_location */
|
|
|
340 debug_nothing_void, /* switch_text_section */
|
|
|
341 0 /* start_end_main_source_file */
|
|
|
342 };
|
|
|
343
|
|
|
344 /* Return a unique string to name an anonymous type. */
|
|
|
345
|
|
|
346 static char *
|
|
|
347 gen_fake_label (void)
|
|
|
348 {
|
|
|
349 char label[10];
|
|
|
350 char *labelstr;
|
|
|
351 sprintf (label, ".%dfake", unnamed_struct_number);
|
|
|
352 unnamed_struct_number++;
|
|
|
353 labelstr = xstrdup (label);
|
|
|
354 return labelstr;
|
|
|
355 }
|
|
|
356
|
|
|
357 /* Return the number which describes TYPE for SDB.
|
|
|
358 For pointers, etc., this function is recursive.
|
|
|
359 Each record, union or enumeral type must already have had a
|
|
|
360 tag number output. */
|
|
|
361
|
|
|
362 /* The number is given by d6d5d4d3d2d1bbbb
|
|
|
363 where bbbb is 4 bit basic type, and di indicate one of notype,ptr,fn,array.
|
|
|
364 Thus, char *foo () has bbbb=T_CHAR
|
|
|
365 d1=D_FCN
|
|
|
366 d2=D_PTR
|
|
|
367 N_BTMASK= 017 1111 basic type field.
|
|
|
368 N_TSHIFT= 2 derived type shift
|
|
|
369 N_BTSHFT= 4 Basic type shift */
|
|
|
370
|
|
|
371 /* Produce the number that describes a pointer, function or array type.
|
|
|
372 PREV is the number describing the target, value or element type.
|
|
|
373 DT_type describes how to transform that type. */
|
|
|
374 #define PUSH_DERIVED_LEVEL(DT_type,PREV) \
|
|
|
375 ((((PREV) & ~(int) N_BTMASK) << (int) N_TSHIFT) \
|
|
|
376 | ((int) DT_type << (int) N_BTSHFT) \
|
|
|
377 | ((PREV) & (int) N_BTMASK))
|
|
|
378
|
|
|
379 /* Number of elements used in sdb_dims. */
|
|
|
380 static int sdb_n_dims = 0;
|
|
|
381
|
|
|
382 /* Table of array dimensions of current type. */
|
|
|
383 static int sdb_dims[SDB_MAX_DIM];
|
|
|
384
|
|
|
385 /* Size of outermost array currently being processed. */
|
|
|
386 static int sdb_type_size = -1;
|
|
|
387
|
|
|
388 static int
|
|
|
389 plain_type (tree type)
|
|
|
390 {
|
|
|
391 int val = plain_type_1 (type, 0);
|
|
|
392
|
|
|
393 /* If we have already saved up some array dimensions, print them now. */
|
|
|
394 if (sdb_n_dims > 0)
|
|
|
395 {
|
|
|
396 int i;
|
|
|
397 PUT_SDB_START_DIM;
|
|
|
398 for (i = sdb_n_dims - 1; i > 0; i--)
|
|
|
399 PUT_SDB_NEXT_DIM (sdb_dims[i]);
|
|
|
400 PUT_SDB_LAST_DIM (sdb_dims[0]);
|
|
|
401 sdb_n_dims = 0;
|
|
|
402
|
|
|
403 sdb_type_size = int_size_in_bytes (type);
|
|
|
404 /* Don't kill sdb if type is not laid out or has variable size. */
|
|
|
405 if (sdb_type_size < 0)
|
|
|
406 sdb_type_size = 0;
|
|
|
407 }
|
|
|
408 /* If we have computed the size of an array containing this type,
|
|
|
409 print it now. */
|
|
|
410 if (sdb_type_size >= 0)
|
|
|
411 {
|
|
|
412 PUT_SDB_SIZE (sdb_type_size);
|
|
|
413 sdb_type_size = -1;
|
|
|
414 }
|
|
|
415 return val;
|
|
|
416 }
|
|
|
417
|
|
|
418 static int
|
|
|
419 template_name_p (tree name)
|
|
|
420 {
|
|
|
421 const char *ptr = IDENTIFIER_POINTER (name);
|
|
|
422 while (*ptr && *ptr != '<')
|
|
|
423 ptr++;
|
|
|
424
|
|
|
425 return *ptr != '\0';
|
|
|
426 }
|
|
|
427
|
|
|
428 static void
|
|
|
429 sdbout_record_type_name (tree type)
|
|
|
430 {
|
|
|
431 const char *name = 0;
|
|
|
432 int no_name;
|
|
|
433
|
|
|
434 if (KNOWN_TYPE_TAG (type))
|
|
|
435 return;
|
|
|
436
|
|
|
437 if (TYPE_NAME (type) != 0)
|
|
|
438 {
|
|
|
439 tree t = 0;
|
|
|
440
|
|
|
441 /* Find the IDENTIFIER_NODE for the type name. */
|
|
|
442 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
|
|
|
443 t = TYPE_NAME (type);
|
|
|
444 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
|
|
|
445 {
|
|
|
446 t = DECL_NAME (TYPE_NAME (type));
|
|
|
447 /* The DECL_NAME for templates includes "<>", which breaks
|
|
|
448 most assemblers. Use its assembler name instead, which
|
|
|
449 has been mangled into being safe. */
|
|
|
450 if (t && template_name_p (t))
|
|
|
451 t = DECL_ASSEMBLER_NAME (TYPE_NAME (type));
|
|
|
452 }
|
|
|
453
|
|
|
454 /* Now get the name as a string, or invent one. */
|
|
|
455 if (t != NULL_TREE)
|
|
|
456 name = IDENTIFIER_POINTER (t);
|
|
|
457 }
|
|
|
458
|
|
|
459 no_name = (name == 0 || *name == 0);
|
|
|
460 if (no_name)
|
|
|
461 name = gen_fake_label ();
|
|
|
462
|
|
|
463 SET_KNOWN_TYPE_TAG (type, name);
|
|
|
464 #ifdef SDB_ALLOW_FORWARD_REFERENCES
|
|
|
465 if (no_name)
|
|
|
466 sdbout_queue_anonymous_type (type);
|
|
|
467 #endif
|
|
|
468 }
|
|
|
469
|
|
|
470 /* Return the .type value for type TYPE.
|
|
|
471
|
|
|
472 LEVEL indicates how many levels deep we have recursed into the type.
|
|
|
473 The SDB debug format can only represent 6 derived levels of types.
|
|
|
474 After that, we must output inaccurate debug info. We deliberately
|
|
|
475 stop before the 7th level, so that ADA recursive types will not give an
|
|
|
476 infinite loop. */
|
|
|
477
|
|
|
478 static int
|
|
|
479 plain_type_1 (tree type, int level)
|
|
|
480 {
|
|
|
481 if (type == 0)
|
|
|
482 type = void_type_node;
|
|
|
483 else if (type == error_mark_node)
|
|
|
484 type = integer_type_node;
|
|
|
485 else
|
|
|
486 type = TYPE_MAIN_VARIANT (type);
|
|
|
487
|
|
|
488 switch (TREE_CODE (type))
|
|
|
489 {
|
|
|
490 case VOID_TYPE:
|
|
|
491 return T_VOID;
|
|
|
492 case BOOLEAN_TYPE:
|
|
|
493 case INTEGER_TYPE:
|
|
|
494 {
|
|
|
495 int size = int_size_in_bytes (type) * BITS_PER_UNIT;
|
|
|
496
|
|
|
497 /* Carefully distinguish all the standard types of C,
|
|
|
498 without messing up if the language is not C.
|
|
|
499 Note that we check only for the names that contain spaces;
|
|
|
500 other names might occur by coincidence in other languages. */
|
|
|
501 if (TYPE_NAME (type) != 0
|
|
|
502 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
|
|
|
503 && DECL_NAME (TYPE_NAME (type)) != 0
|
|
|
504 && TREE_CODE (DECL_NAME (TYPE_NAME (type))) == IDENTIFIER_NODE)
|
|
|
505 {
|
|
|
506 const char *const name
|
|
|
507 = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
|
|
|
508
|
|
|
509 if (!strcmp (name, "char"))
|
|
|
510 return T_CHAR;
|
|
|
511 if (!strcmp (name, "unsigned char"))
|
|
|
512 return T_UCHAR;
|
|
|
513 if (!strcmp (name, "signed char"))
|
|
|
514 return T_CHAR;
|
|
|
515 if (!strcmp (name, "int"))
|
|
|
516 return T_INT;
|
|
|
517 if (!strcmp (name, "unsigned int"))
|
|
|
518 return T_UINT;
|
|
|
519 if (!strcmp (name, "short int"))
|
|
|
520 return T_SHORT;
|
|
|
521 if (!strcmp (name, "short unsigned int"))
|
|
|
522 return T_USHORT;
|
|
|
523 if (!strcmp (name, "long int"))
|
|
|
524 return T_LONG;
|
|
|
525 if (!strcmp (name, "long unsigned int"))
|
|
|
526 return T_ULONG;
|
|
|
527 }
|
|
|
528
|
|
|
529 if (size == INT_TYPE_SIZE)
|
|
|
530 return (TYPE_UNSIGNED (type) ? T_UINT : T_INT);
|
|
|
531 if (size == CHAR_TYPE_SIZE)
|
|
|
532 return (TYPE_UNSIGNED (type) ? T_UCHAR : T_CHAR);
|
|
|
533 if (size == SHORT_TYPE_SIZE)
|
|
|
534 return (TYPE_UNSIGNED (type) ? T_USHORT : T_SHORT);
|
|
|
535 if (size == LONG_TYPE_SIZE)
|
|
|
536 return (TYPE_UNSIGNED (type) ? T_ULONG : T_LONG);
|
|
|
537 if (size == LONG_LONG_TYPE_SIZE) /* better than nothing */
|
|
|
538 return (TYPE_UNSIGNED (type) ? T_ULONG : T_LONG);
|
|
|
539 return 0;
|
|
|
540 }
|
|
|
541
|
|
|
542 case REAL_TYPE:
|
|
|
543 {
|
|
|
544 int precision = TYPE_PRECISION (type);
|
|
|
545 if (precision == FLOAT_TYPE_SIZE)
|
|
|
546 return T_FLOAT;
|
|
|
547 if (precision == DOUBLE_TYPE_SIZE)
|
|
|
548 return T_DOUBLE;
|
|
|
549 #ifdef EXTENDED_SDB_BASIC_TYPES
|
|
|
550 if (precision == LONG_DOUBLE_TYPE_SIZE)
|
|
|
551 return T_LNGDBL;
|
|
|
552 #else
|
|
|
553 if (precision == LONG_DOUBLE_TYPE_SIZE)
|
|
|
554 return T_DOUBLE; /* better than nothing */
|
|
|
555 #endif
|
|
|
556 return 0;
|
|
|
557 }
|
|
|
558
|
|
|
559 case ARRAY_TYPE:
|
|
|
560 {
|
|
|
561 int m;
|
|
|
562 if (level >= 6)
|
|
|
563 return T_VOID;
|
|
|
564 else
|
|
|
565 m = plain_type_1 (TREE_TYPE (type), level+1);
|
|
|
566 if (sdb_n_dims < SDB_MAX_DIM)
|
|
|
567 sdb_dims[sdb_n_dims++]
|
|
|
568 = (TYPE_DOMAIN (type)
|
|
|
569 && TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != 0
|
|
|
570 && TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != 0
|
|
|
571 && host_integerp (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
|
|
|
572 && host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0)
|
|
|
573 ? (tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), 0)
|
|
|
574 - tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), 0) + 1)
|
|
|
575 : 0);
|
|
|
576
|
|
|
577 return PUSH_DERIVED_LEVEL (DT_ARY, m);
|
|
|
578 }
|
|
|
579
|
|
|
580 case RECORD_TYPE:
|
|
|
581 case UNION_TYPE:
|
|
|
582 case QUAL_UNION_TYPE:
|
|
|
583 case ENUMERAL_TYPE:
|
|
|
584 {
|
|
|
585 const char *tag;
|
|
|
586 #ifdef SDB_ALLOW_FORWARD_REFERENCES
|
|
|
587 sdbout_record_type_name (type);
|
|
|
588 #endif
|
|
|
589 #ifndef SDB_ALLOW_UNKNOWN_REFERENCES
|
|
|
590 if ((TREE_ASM_WRITTEN (type) && KNOWN_TYPE_TAG (type) != 0)
|
|
|
591 #ifdef SDB_ALLOW_FORWARD_REFERENCES
|
|
|
592 || TYPE_MODE (type) != VOIDmode
|
|
|
593 #endif
|
|
|
594 )
|
|
|
595 #endif
|
|
|
596 {
|
|
|
597 /* Output the referenced structure tag name
|
|
|
598 only if the .def has already been finished.
|
|
|
599 At least on 386, the Unix assembler
|
|
|
600 cannot handle forward references to tags. */
|
|
|
601 /* But the 88100, it requires them, sigh... */
|
|
|
602 /* And the MIPS requires unknown refs as well... */
|
|
|
603 tag = KNOWN_TYPE_TAG (type);
|
|
|
604 PUT_SDB_TAG (tag);
|
|
|
605 /* These 3 lines used to follow the close brace.
|
|
|
606 However, a size of 0 without a tag implies a tag of 0,
|
|
|
607 so if we don't know a tag, we can't mention the size. */
|
|
|
608 sdb_type_size = int_size_in_bytes (type);
|
|
|
609 if (sdb_type_size < 0)
|
|
|
610 sdb_type_size = 0;
|
|
|
611 }
|
|
|
612 return ((TREE_CODE (type) == RECORD_TYPE) ? T_STRUCT
|
|
|
613 : (TREE_CODE (type) == UNION_TYPE) ? T_UNION
|
|
|
614 : (TREE_CODE (type) == QUAL_UNION_TYPE) ? T_UNION
|
|
|
615 : T_ENUM);
|
|
|
616 }
|
|
|
617 case POINTER_TYPE:
|
|
|
618 case REFERENCE_TYPE:
|
|
|
619 {
|
|
|
620 int m;
|
|
|
621 if (level >= 6)
|
|
|
622 return T_VOID;
|
|
|
623 else
|
|
|
624 m = plain_type_1 (TREE_TYPE (type), level+1);
|
|
|
625 return PUSH_DERIVED_LEVEL (DT_PTR, m);
|
|
|
626 }
|
|
|
627 case FUNCTION_TYPE:
|
|
|
628 case METHOD_TYPE:
|
|
|
629 {
|
|
|
630 int m;
|
|
|
631 if (level >= 6)
|
|
|
632 return T_VOID;
|
|
|
633 else
|
|
|
634 m = plain_type_1 (TREE_TYPE (type), level+1);
|
|
|
635 return PUSH_DERIVED_LEVEL (DT_FCN, m);
|
|
|
636 }
|
|
|
637 default:
|
|
|
638 return 0;
|
|
|
639 }
|
|
|
640 }
|
|
|
641
|
|
|
642 /* Output the symbols defined in block number DO_BLOCK.
|
|
|
643
|
|
|
644 This function works by walking the tree structure of blocks,
|
|
|
645 counting blocks until it finds the desired block. */
|
|
|
646
|
|
|
647 static int do_block = 0;
|
|
|
648
|
|
|
649 static void
|
|
|
650 sdbout_block (tree block)
|
|
|
651 {
|
|
|
652 while (block)
|
|
|
653 {
|
|
|
654 /* Ignore blocks never expanded or otherwise marked as real. */
|
|
|
655 if (TREE_USED (block))
|
|
|
656 {
|
|
|
657 /* When we reach the specified block, output its symbols. */
|
|
|
658 if (BLOCK_NUMBER (block) == do_block)
|
|
|
659 sdbout_syms (BLOCK_VARS (block));
|
|
|
660
|
|
|
661 /* If we are past the specified block, stop the scan. */
|
|
|
662 if (BLOCK_NUMBER (block) > do_block)
|
|
|
663 return;
|
|
|
664
|
|
|
665 /* Scan the blocks within this block. */
|
|
|
666 sdbout_block (BLOCK_SUBBLOCKS (block));
|
|
|
667 }
|
|
|
668
|
|
|
669 block = BLOCK_CHAIN (block);
|
|
|
670 }
|
|
|
671 }
|
|
|
672
|
|
|
673 /* Call sdbout_symbol on each decl in the chain SYMS. */
|
|
|
674
|
|
|
675 static void
|
|
|
676 sdbout_syms (tree syms)
|
|
|
677 {
|
|
|
678 while (syms)
|
|
|
679 {
|
|
|
680 if (TREE_CODE (syms) != LABEL_DECL)
|
|
|
681 sdbout_symbol (syms, 1);
|
|
|
682 syms = TREE_CHAIN (syms);
|
|
|
683 }
|
|
|
684 }
|
|
|
685
|
|
|
686 /* Output SDB information for a symbol described by DECL.
|
|
|
687 LOCAL is nonzero if the symbol is not file-scope. */
|
|
|
688
|
|
|
689 void
|
|
|
690 sdbout_symbol (tree decl, int local)
|
|
|
691 {
|
|
|
692 tree type = TREE_TYPE (decl);
|
|
|
693 tree context = NULL_TREE;
|
|
|
694 rtx value;
|
|
|
695 int regno = -1;
|
|
|
696 const char *name;
|
|
|
697
|
|
|
698 /* If we are called before sdbout_init is run, just save the symbol
|
|
|
699 for later. */
|
|
|
700 if (!sdbout_initialized)
|
|
|
701 {
|
|
|
702 preinit_symbols = tree_cons (0, decl, preinit_symbols);
|
|
|
703 return;
|
|
|
704 }
|
|
|
705
|
|
|
706 sdbout_one_type (type);
|
|
|
707
|
|
|
708 switch (TREE_CODE (decl))
|
|
|
709 {
|
|
|
710 case CONST_DECL:
|
|
|
711 /* Enum values are defined by defining the enum type. */
|
|
|
712 return;
|
|
|
713
|
|
|
714 case FUNCTION_DECL:
|
|
|
715 /* Don't mention a nested function under its parent. */
|
|
|
716 context = decl_function_context (decl);
|
|
|
717 if (context == current_function_decl)
|
|
|
718 return;
|
|
|
719 /* Check DECL_INITIAL to distinguish declarations from definitions.
|
|
|
720 Don't output debug info here for declarations; they will have
|
|
|
721 a DECL_INITIAL value of 0. */
|
|
|
722 if (! DECL_INITIAL (decl))
|
|
|
723 return;
|
|
|
724 if (!MEM_P (DECL_RTL (decl))
|
|
|
725 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
|
|
|
726 return;
|
|
|
727 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
|
|
|
728 PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
|
|
|
729 PUT_SDB_SCL (TREE_PUBLIC (decl) ? C_EXT : C_STAT);
|
|
|
730 break;
|
|
|
731
|
|
|
732 case TYPE_DECL:
|
|
|
733 /* Done with tagged types. */
|
|
|
734 if (DECL_NAME (decl) == 0)
|
|
|
735 return;
|
|
|
736 if (DECL_IGNORED_P (decl))
|
|
|
737 return;
|
|
|
738 /* Don't output intrinsic types. GAS chokes on SDB .def
|
|
|
739 statements that contain identifiers with embedded spaces
|
|
|
740 (eg "unsigned long"). */
|
|
|
741 if (DECL_IS_BUILTIN (decl))
|
|
|
742 return;
|
|
|
743
|
|
|
744 /* Output typedef name. */
|
|
|
745 if (template_name_p (DECL_NAME (decl)))
|
|
|
746 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
|
|
|
747 else
|
|
|
748 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_NAME (decl)));
|
|
|
749 PUT_SDB_SCL (C_TPDEF);
|
|
|
750 break;
|
|
|
751
|
|
|
752 case PARM_DECL:
|
|
|
753 /* Parm decls go in their own separate chains
|
|
|
754 and are output by sdbout_reg_parms and sdbout_parms. */
|
|
|
755 gcc_unreachable ();
|
|
|
756
|
|
|
757 case VAR_DECL:
|
|
|
758 /* Don't mention a variable that is external.
|
|
|
759 Let the file that defines it describe it. */
|
|
|
760 if (DECL_EXTERNAL (decl))
|
|
|
761 return;
|
|
|
762
|
|
|
763 /* Ignore __FUNCTION__, etc. */
|
|
|
764 if (DECL_IGNORED_P (decl))
|
|
|
765 return;
|
|
|
766
|
|
|
767 /* If there was an error in the declaration, don't dump core
|
|
|
768 if there is no RTL associated with the variable doesn't
|
|
|
769 exist. */
|
|
|
770 if (!DECL_RTL_SET_P (decl))
|
|
|
771 return;
|
|
|
772
|
|
|
773 SET_DECL_RTL (decl,
|
|
|
774 eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
|
|
|
775 #ifdef LEAF_REG_REMAP
|
|
|
776 if (current_function_uses_only_leaf_regs)
|
|
|
777 leaf_renumber_regs_insn (DECL_RTL (decl));
|
|
|
778 #endif
|
|
|
779 value = DECL_RTL (decl);
|
|
|
780
|
|
|
781 /* Don't mention a variable at all
|
|
|
782 if it was completely optimized into nothingness.
|
|
|
783
|
|
|
784 If DECL was from an inline function, then its rtl
|
|
|
785 is not identically the rtl that was used in this
|
|
|
786 particular compilation. */
|
|
|
787 if (REG_P (value))
|
|
|
788 {
|
|
|
789 regno = REGNO (value);
|
|
|
790 if (regno >= FIRST_PSEUDO_REGISTER)
|
|
|
791 return;
|
|
|
792 }
|
|
|
793 else if (GET_CODE (value) == SUBREG)
|
|
|
794 {
|
|
|
795 while (GET_CODE (value) == SUBREG)
|
|
|
796 value = SUBREG_REG (value);
|
|
|
797 if (REG_P (value))
|
|
|
798 {
|
|
|
799 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
|
|
|
800 return;
|
|
|
801 }
|
|
|
802 regno = REGNO (alter_subreg (&value));
|
|
|
803 SET_DECL_RTL (decl, value);
|
|
|
804 }
|
|
|
805 /* Don't output anything if an auto variable
|
|
|
806 gets RTL that is static.
|
|
|
807 GAS version 2.2 can't handle such output. */
|
|
|
808 else if (MEM_P (value) && CONSTANT_P (XEXP (value, 0))
|
|
|
809 && ! TREE_STATIC (decl))
|
|
|
810 return;
|
|
|
811
|
|
|
812 /* Emit any structure, union, or enum type that has not been output.
|
|
|
813 This occurs for tag-less structs (et al) used to declare variables
|
|
|
814 within functions. */
|
|
|
815 if (TREE_CODE (type) == ENUMERAL_TYPE
|
|
|
816 || TREE_CODE (type) == RECORD_TYPE
|
|
|
817 || TREE_CODE (type) == UNION_TYPE
|
|
|
818 || TREE_CODE (type) == QUAL_UNION_TYPE)
|
|
|
819 {
|
|
|
820 if (COMPLETE_TYPE_P (type) /* not a forward reference */
|
|
|
821 && KNOWN_TYPE_TAG (type) == 0) /* not yet declared */
|
|
|
822 sdbout_one_type (type);
|
|
|
823 }
|
|
|
824
|
|
|
825 /* Defer SDB information for top-level initialized variables! */
|
|
|
826 if (! local
|
|
|
827 && MEM_P (value)
|
|
|
828 && DECL_INITIAL (decl))
|
|
|
829 return;
|
|
|
830
|
|
|
831 /* C++ in 2.3 makes nameless symbols. That will be fixed later.
|
|
|
832 For now, avoid crashing. */
|
|
|
833 if (DECL_NAME (decl) == NULL_TREE)
|
|
|
834 return;
|
|
|
835
|
|
|
836 /* Record the name for, starting a symtab entry. */
|
|
|
837 if (local)
|
|
|
838 name = IDENTIFIER_POINTER (DECL_NAME (decl));
|
|
|
839 else
|
|
|
840 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
|
|
841
|
|
|
842 if (MEM_P (value)
|
|
|
843 && GET_CODE (XEXP (value, 0)) == SYMBOL_REF)
|
|
|
844 {
|
|
|
845 PUT_SDB_DEF (name);
|
|
|
846 if (TREE_PUBLIC (decl))
|
|
|
847 {
|
|
|
848 PUT_SDB_VAL (XEXP (value, 0));
|
|
|
849 PUT_SDB_SCL (C_EXT);
|
|
|
850 }
|
|
|
851 else
|
|
|
852 {
|
|
|
853 PUT_SDB_VAL (XEXP (value, 0));
|
|
|
854 PUT_SDB_SCL (C_STAT);
|
|
|
855 }
|
|
|
856 }
|
|
|
857 else if (regno >= 0)
|
|
|
858 {
|
|
|
859 PUT_SDB_DEF (name);
|
|
|
860 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (regno));
|
|
|
861 PUT_SDB_SCL (C_REG);
|
|
|
862 }
|
|
|
863 else if (MEM_P (value)
|
|
|
864 && (MEM_P (XEXP (value, 0))
|
|
|
865 || (REG_P (XEXP (value, 0))
|
|
|
866 && REGNO (XEXP (value, 0)) != HARD_FRAME_POINTER_REGNUM
|
|
|
867 && REGNO (XEXP (value, 0)) != STACK_POINTER_REGNUM)))
|
|
|
868 /* If the value is indirect by memory or by a register
|
|
|
869 that isn't the frame pointer
|
|
|
870 then it means the object is variable-sized and address through
|
|
|
871 that register or stack slot. COFF has no way to represent this
|
|
|
872 so all we can do is output the variable as a pointer. */
|
|
|
873 {
|
|
|
874 PUT_SDB_DEF (name);
|
|
|
875 if (REG_P (XEXP (value, 0)))
|
|
|
876 {
|
|
|
877 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (XEXP (value, 0))));
|
|
|
878 PUT_SDB_SCL (C_REG);
|
|
|
879 }
|
|
|
880 else
|
|
|
881 {
|
|
|
882 /* DECL_RTL looks like (MEM (MEM (PLUS (REG...)
|
|
|
883 (CONST_INT...)))).
|
|
|
884 We want the value of that CONST_INT. */
|
|
|
885 /* Encore compiler hates a newline in a macro arg, it seems. */
|
|
|
886 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
|
|
|
887 (XEXP (XEXP (value, 0), 0)));
|
|
|
888 PUT_SDB_SCL (C_AUTO);
|
|
|
889 }
|
|
|
890
|
|
|
891 /* Effectively do build_pointer_type, but don't cache this type,
|
|
|
892 since it might be temporary whereas the type it points to
|
|
|
893 might have been saved for inlining. */
|
|
|
894 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
|
|
|
895 type = make_node (POINTER_TYPE);
|
|
|
896 TREE_TYPE (type) = TREE_TYPE (decl);
|
|
|
897 }
|
|
|
898 else if (MEM_P (value)
|
|
|
899 && ((GET_CODE (XEXP (value, 0)) == PLUS
|
|
|
900 && REG_P (XEXP (XEXP (value, 0), 0))
|
|
|
901 && GET_CODE (XEXP (XEXP (value, 0), 1)) == CONST_INT)
|
|
|
902 /* This is for variables which are at offset zero from
|
|
|
903 the frame pointer. This happens on the Alpha.
|
|
|
904 Non-frame pointer registers are excluded above. */
|
|
|
905 || (REG_P (XEXP (value, 0)))))
|
|
|
906 {
|
|
|
907 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
|
|
|
908 or (MEM (REG...)). We want the value of that CONST_INT
|
|
|
909 or zero. */
|
|
|
910 PUT_SDB_DEF (name);
|
|
|
911 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET (XEXP (value, 0)));
|
|
|
912 PUT_SDB_SCL (C_AUTO);
|
|
|
913 }
|
|
|
914 else
|
|
|
915 {
|
|
|
916 /* It is something we don't know how to represent for SDB. */
|
|
|
917 return;
|
|
|
918 }
|
|
|
919 break;
|
|
|
920
|
|
|
921 default:
|
|
|
922 break;
|
|
|
923 }
|
|
|
924 PUT_SDB_TYPE (plain_type (type));
|
|
|
925 PUT_SDB_ENDEF;
|
|
|
926 }
|
|
|
927
|
|
|
928 /* Output SDB information for a top-level initialized variable
|
|
|
929 that has been delayed. */
|
|
|
930
|
|
|
931 static void
|
|
|
932 sdbout_toplevel_data (tree decl)
|
|
|
933 {
|
|
|
934 tree type = TREE_TYPE (decl);
|
|
|
935
|
|
|
936 if (DECL_IGNORED_P (decl))
|
|
|
937 return;
|
|
|
938
|
|
|
939 gcc_assert (TREE_CODE (decl) == VAR_DECL);
|
|
|
940 gcc_assert (MEM_P (DECL_RTL (decl)));
|
|
|
941 gcc_assert (DECL_INITIAL (decl));
|
|
|
942
|
|
|
943 PUT_SDB_DEF (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
|
|
|
944 PUT_SDB_VAL (XEXP (DECL_RTL (decl), 0));
|
|
|
945 if (TREE_PUBLIC (decl))
|
|
|
946 {
|
|
|
947 PUT_SDB_SCL (C_EXT);
|
|
|
948 }
|
|
|
949 else
|
|
|
950 {
|
|
|
951 PUT_SDB_SCL (C_STAT);
|
|
|
952 }
|
|
|
953 PUT_SDB_TYPE (plain_type (type));
|
|
|
954 PUT_SDB_ENDEF;
|
|
|
955 }
|
|
|
956
|
|
|
957 #ifdef SDB_ALLOW_FORWARD_REFERENCES
|
|
|
958
|
|
|
959 /* Machinery to record and output anonymous types. */
|
|
|
960
|
|
|
961 static void
|
|
|
962 sdbout_queue_anonymous_type (tree type)
|
|
|
963 {
|
|
|
964 anonymous_types = tree_cons (NULL_TREE, type, anonymous_types);
|
|
|
965 }
|
|
|
966
|
|
|
967 static void
|
|
|
968 sdbout_dequeue_anonymous_types (void)
|
|
|
969 {
|
|
|
970 tree types, link;
|
|
|
971
|
|
|
972 while (anonymous_types)
|
|
|
973 {
|
|
|
974 types = nreverse (anonymous_types);
|
|
|
975 anonymous_types = NULL_TREE;
|
|
|
976
|
|
|
977 for (link = types; link; link = TREE_CHAIN (link))
|
|
|
978 {
|
|
|
979 tree type = TREE_VALUE (link);
|
|
|
980
|
|
|
981 if (type && ! TREE_ASM_WRITTEN (type))
|
|
|
982 sdbout_one_type (type);
|
|
|
983 }
|
|
|
984 }
|
|
|
985 }
|
|
|
986
|
|
|
987 #endif
|
|
|
988
|
|
|
989 /* Given a chain of ..._TYPE nodes, all of which have names,
|
|
|
990 output definitions of those names, as typedefs. */
|
|
|
991
|
|
|
992 void
|
|
|
993 sdbout_types (tree types)
|
|
|
994 {
|
|
|
995 tree link;
|
|
|
996
|
|
|
997 for (link = types; link; link = TREE_CHAIN (link))
|
|
|
998 sdbout_one_type (link);
|
|
|
999
|
|
|
1000 #ifdef SDB_ALLOW_FORWARD_REFERENCES
|
|
|
1001 sdbout_dequeue_anonymous_types ();
|
|
|
1002 #endif
|
|
|
1003 }
|
|
|
1004
|
|
|
1005 static void
|
|
|
1006 sdbout_type (tree type)
|
|
|
1007 {
|
|
|
1008 if (type == error_mark_node)
|
|
|
1009 type = integer_type_node;
|
|
|
1010 PUT_SDB_TYPE (plain_type (type));
|
|
|
1011 }
|
|
|
1012
|
|
|
1013 /* Output types of the fields of type TYPE, if they are structs.
|
|
|
1014
|
|
|
1015 Formerly did not chase through pointer types, since that could be circular.
|
|
|
1016 They must come before TYPE, since forward refs are not allowed.
|
|
|
1017 Now james@bigtex.cactus.org says to try them. */
|
|
|
1018
|
|
|
1019 static void
|
|
|
1020 sdbout_field_types (tree type)
|
|
|
1021 {
|
|
|
1022 tree tail;
|
|
|
1023
|
|
|
1024 for (tail = TYPE_FIELDS (type); tail; tail = TREE_CHAIN (tail))
|
|
|
1025 /* This condition should match the one for emitting the actual
|
|
|
1026 members below. */
|
|
|
1027 if (TREE_CODE (tail) == FIELD_DECL
|
|
|
1028 && DECL_NAME (tail)
|
|
|
1029 && DECL_SIZE (tail)
|
|
|
1030 && host_integerp (DECL_SIZE (tail), 1)
|
|
|
1031 && host_integerp (bit_position (tail), 0))
|
|
|
1032 {
|
|
|
1033 if (POINTER_TYPE_P (TREE_TYPE (tail)))
|
|
|
1034 sdbout_one_type (TREE_TYPE (TREE_TYPE (tail)));
|
|
|
1035 else
|
|
|
1036 sdbout_one_type (TREE_TYPE (tail));
|
|
|
1037 }
|
|
|
1038 }
|
|
|
1039
|
|
|
1040 /* Use this to put out the top level defined record and union types
|
|
|
1041 for later reference. If this is a struct with a name, then put that
|
|
|
1042 name out. Other unnamed structs will have .xxfake labels generated so
|
|
|
1043 that they may be referred to later.
|
|
|
1044 The label will be stored in the KNOWN_TYPE_TAG slot of a type.
|
|
|
1045 It may NOT be called recursively. */
|
|
|
1046
|
|
|
1047 static void
|
|
|
1048 sdbout_one_type (tree type)
|
|
|
1049 {
|
|
|
1050 if (current_function_decl != NULL_TREE
|
|
|
1051 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
|
|
|
1052 ; /* Don't change section amid function. */
|
|
|
1053 else
|
|
|
1054 switch_to_section (text_section);
|
|
|
1055
|
|
|
1056 switch (TREE_CODE (type))
|
|
|
1057 {
|
|
|
1058 case RECORD_TYPE:
|
|
|
1059 case UNION_TYPE:
|
|
|
1060 case QUAL_UNION_TYPE:
|
|
|
1061 case ENUMERAL_TYPE:
|
|
|
1062 type = TYPE_MAIN_VARIANT (type);
|
|
|
1063 /* Don't output a type twice. */
|
|
|
1064 if (TREE_ASM_WRITTEN (type))
|
|
|
1065 /* James said test TREE_ASM_BEING_WRITTEN here. */
|
|
|
1066 return;
|
|
|
1067
|
|
|
1068 /* Output nothing if type is not yet defined. */
|
|
|
1069 if (!COMPLETE_TYPE_P (type))
|
|
|
1070 return;
|
|
|
1071
|
|
|
1072 TREE_ASM_WRITTEN (type) = 1;
|
|
|
1073
|
|
|
1074 /* This is reputed to cause trouble with the following case,
|
|
|
1075 but perhaps checking TYPE_SIZE above will fix it. */
|
|
|
1076
|
|
|
1077 /* Here is a testcase:
|
|
|
1078
|
|
|
1079 struct foo {
|
|
|
1080 struct badstr *bbb;
|
|
|
1081 } forwardref;
|
|
|
1082
|
|
|
1083 typedef struct intermediate {
|
|
|
1084 int aaaa;
|
|
|
1085 } intermediate_ref;
|
|
|
1086
|
|
|
1087 typedef struct badstr {
|
|
|
1088 int ccccc;
|
|
|
1089 } badtype; */
|
|
|
1090
|
|
|
1091 /* This change, which ought to make better output,
|
|
|
1092 used to make the COFF assembler unhappy.
|
|
|
1093 Changes involving KNOWN_TYPE_TAG may fix the problem. */
|
|
|
1094 /* Before really doing anything, output types we want to refer to. */
|
|
|
1095 /* Note that in version 1 the following two lines
|
|
|
1096 are not used if forward references are in use. */
|
|
|
1097 if (TREE_CODE (type) != ENUMERAL_TYPE)
|
|
|
1098 sdbout_field_types (type);
|
|
|
1099
|
|
|
1100 /* Output a structure type. */
|
|
|
1101 {
|
|
|
1102 int size = int_size_in_bytes (type);
|
|
|
1103 int member_scl = 0;
|
|
|
1104 tree tem;
|
|
|
1105
|
|
|
1106 /* Record the type tag, but not in its permanent place just yet. */
|
|
|
1107 sdbout_record_type_name (type);
|
|
|
1108
|
|
|
1109 PUT_SDB_DEF (KNOWN_TYPE_TAG (type));
|
|
|
1110
|
|
|
1111 switch (TREE_CODE (type))
|
|
|
1112 {
|
|
|
1113 case UNION_TYPE:
|
|
|
1114 case QUAL_UNION_TYPE:
|
|
|
1115 PUT_SDB_SCL (C_UNTAG);
|
|
|
1116 PUT_SDB_TYPE (T_UNION);
|
|
|
1117 member_scl = C_MOU;
|
|
|
1118 break;
|
|
|
1119
|
|
|
1120 case RECORD_TYPE:
|
|
|
1121 PUT_SDB_SCL (C_STRTAG);
|
|
|
1122 PUT_SDB_TYPE (T_STRUCT);
|
|
|
1123 member_scl = C_MOS;
|
|
|
1124 break;
|
|
|
1125
|
|
|
1126 case ENUMERAL_TYPE:
|
|
|
1127 PUT_SDB_SCL (C_ENTAG);
|
|
|
1128 PUT_SDB_TYPE (T_ENUM);
|
|
|
1129 member_scl = C_MOE;
|
|
|
1130 break;
|
|
|
1131
|
|
|
1132 default:
|
|
|
1133 break;
|
|
|
1134 }
|
|
|
1135
|
|
|
1136 PUT_SDB_SIZE (size);
|
|
|
1137 PUT_SDB_ENDEF;
|
|
|
1138
|
|
|
1139 /* Print out the base class information with fields
|
|
|
1140 named after the types they hold. */
|
|
|
1141 /* This is only relevant to aggregate types. TYPE_BINFO is used
|
|
|
1142 for other purposes in an ENUMERAL_TYPE, so we must exclude that
|
|
|
1143 case. */
|
|
|
1144 if (TREE_CODE (type) != ENUMERAL_TYPE && TYPE_BINFO (type))
|
|
|
1145 {
|
|
|
1146 int i;
|
|
|
1147 tree binfo, child;
|
|
|
1148
|
|
|
1149 for (binfo = TYPE_BINFO (type), i = 0;
|
|
|
1150 BINFO_BASE_ITERATE (binfo, i, child); i++)
|
|
|
1151 {
|
|
|
1152 tree child_type = BINFO_TYPE (child);
|
|
|
1153 tree child_type_name;
|
|
|
1154
|
|
|
1155 if (TYPE_NAME (child_type) == 0)
|
|
|
1156 continue;
|
|
|
1157 if (TREE_CODE (TYPE_NAME (child_type)) == IDENTIFIER_NODE)
|
|
|
1158 child_type_name = TYPE_NAME (child_type);
|
|
|
1159 else if (TREE_CODE (TYPE_NAME (child_type)) == TYPE_DECL)
|
|
|
1160 {
|
|
|
1161 child_type_name = DECL_NAME (TYPE_NAME (child_type));
|
|
|
1162 if (child_type_name && template_name_p (child_type_name))
|
|
|
1163 child_type_name
|
|
|
1164 = DECL_ASSEMBLER_NAME (TYPE_NAME (child_type));
|
|
|
1165 }
|
|
|
1166 else
|
|
|
1167 continue;
|
|
|
1168
|
|
|
1169 PUT_SDB_DEF (IDENTIFIER_POINTER (child_type_name));
|
|
|
1170 PUT_SDB_INT_VAL (tree_low_cst (BINFO_OFFSET (child), 0));
|
|
|
1171 PUT_SDB_SCL (member_scl);
|
|
|
1172 sdbout_type (BINFO_TYPE (child));
|
|
|
1173 PUT_SDB_ENDEF;
|
|
|
1174 }
|
|
|
1175 }
|
|
|
1176
|
|
|
1177 /* Output the individual fields. */
|
|
|
1178
|
|
|
1179 if (TREE_CODE (type) == ENUMERAL_TYPE)
|
|
|
1180 {
|
|
|
1181 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
|
|
|
1182 {
|
|
|
1183 tree value = TREE_VALUE (tem);
|
|
|
1184
|
|
|
1185 if (TREE_CODE (value) == CONST_DECL)
|
|
|
1186 value = DECL_INITIAL (value);
|
|
|
1187
|
|
|
1188 if (host_integerp (value, 0))
|
|
|
1189 {
|
|
|
1190 PUT_SDB_DEF (IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
|
|
|
1191 PUT_SDB_INT_VAL (tree_low_cst (value, 0));
|
|
|
1192 PUT_SDB_SCL (C_MOE);
|
|
|
1193 PUT_SDB_TYPE (T_MOE);
|
|
|
1194 PUT_SDB_ENDEF;
|
|
|
1195 }
|
|
|
1196 }
|
|
|
1197 }
|
|
|
1198 else /* record or union type */
|
|
|
1199 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
|
|
|
1200 /* Output the name, type, position (in bits), size (in bits)
|
|
|
1201 of each field. */
|
|
|
1202
|
|
|
1203 /* Omit here the nameless fields that are used to skip bits.
|
|
|
1204 Also omit fields with variable size or position.
|
|
|
1205 Also omit non FIELD_DECL nodes that GNU C++ may put here. */
|
|
|
1206 if (TREE_CODE (tem) == FIELD_DECL
|
|
|
1207 && DECL_NAME (tem)
|
|
|
1208 && DECL_SIZE (tem)
|
|
|
1209 && host_integerp (DECL_SIZE (tem), 1)
|
|
|
1210 && host_integerp (bit_position (tem), 0))
|
|
|
1211 {
|
|
|
1212 const char *name;
|
|
|
1213
|
|
|
1214 name = IDENTIFIER_POINTER (DECL_NAME (tem));
|
|
|
1215 PUT_SDB_DEF (name);
|
|
|
1216 if (DECL_BIT_FIELD_TYPE (tem))
|
|
|
1217 {
|
|
|
1218 PUT_SDB_INT_VAL (int_bit_position (tem));
|
|
|
1219 PUT_SDB_SCL (C_FIELD);
|
|
|
1220 sdbout_type (DECL_BIT_FIELD_TYPE (tem));
|
|
|
1221 PUT_SDB_SIZE (tree_low_cst (DECL_SIZE (tem), 1));
|
|
|
1222 }
|
|
|
1223 else
|
|
|
1224 {
|
|
|
1225 PUT_SDB_INT_VAL (int_bit_position (tem) / BITS_PER_UNIT);
|
|
|
1226 PUT_SDB_SCL (member_scl);
|
|
|
1227 sdbout_type (TREE_TYPE (tem));
|
|
|
1228 }
|
|
|
1229 PUT_SDB_ENDEF;
|
|
|
1230 }
|
|
|
1231 /* Output end of a structure,union, or enumeral definition. */
|
|
|
1232
|
|
|
1233 PUT_SDB_PLAIN_DEF ("eos");
|
|
|
1234 PUT_SDB_INT_VAL (size);
|
|
|
1235 PUT_SDB_SCL (C_EOS);
|
|
|
1236 PUT_SDB_TAG (KNOWN_TYPE_TAG (type));
|
|
|
1237 PUT_SDB_SIZE (size);
|
|
|
1238 PUT_SDB_ENDEF;
|
|
|
1239 break;
|
|
|
1240
|
|
|
1241 default:
|
|
|
1242 break;
|
|
|
1243 }
|
|
|
1244 }
|
|
|
1245 }
|
|
|
1246
|
|
|
1247 /* The following two functions output definitions of function parameters.
|
|
|
1248 Each parameter gets a definition locating it in the parameter list.
|
|
|
1249 Each parameter that is a register variable gets a second definition
|
|
|
1250 locating it in the register.
|
|
|
1251
|
|
|
1252 Printing or argument lists in gdb uses the definitions that
|
|
|
1253 locate in the parameter list. But reference to the variable in
|
|
|
1254 expressions uses preferentially the definition as a register. */
|
|
|
1255
|
|
|
1256 /* Output definitions, referring to storage in the parmlist,
|
|
|
1257 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
|
|
|
1258
|
|
|
1259 static void
|
|
|
1260 sdbout_parms (tree parms)
|
|
|
1261 {
|
|
|
1262 for (; parms; parms = TREE_CHAIN (parms))
|
|
|
1263 if (DECL_NAME (parms))
|
|
|
1264 {
|
|
|
1265 int current_sym_value = 0;
|
|
|
1266 const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
|
|
|
1267
|
|
|
1268 if (name == 0 || *name == 0)
|
|
|
1269 name = gen_fake_label ();
|
|
|
1270
|
|
|
1271 /* Perform any necessary register eliminations on the parameter's rtl,
|
|
|
1272 so that the debugging output will be accurate. */
|
|
|
1273 DECL_INCOMING_RTL (parms)
|
|
|
1274 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
|
|
|
1275 SET_DECL_RTL (parms,
|
|
|
1276 eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
|
|
|
1277
|
|
|
1278 if (PARM_PASSED_IN_MEMORY (parms))
|
|
|
1279 {
|
|
|
1280 rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
|
|
|
1281 tree type;
|
|
|
1282
|
|
|
1283 /* ??? Here we assume that the parm address is indexed
|
|
|
1284 off the frame pointer or arg pointer.
|
|
|
1285 If that is not true, we produce meaningless results,
|
|
|
1286 but do not crash. */
|
|
|
1287 if (GET_CODE (addr) == PLUS
|
|
|
1288 && GET_CODE (XEXP (addr, 1)) == CONST_INT)
|
|
|
1289 current_sym_value = INTVAL (XEXP (addr, 1));
|
|
|
1290 else
|
|
|
1291 current_sym_value = 0;
|
|
|
1292
|
|
|
1293 if (REG_P (DECL_RTL (parms))
|
|
|
1294 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
|
|
|
1295 type = DECL_ARG_TYPE (parms);
|
|
|
1296 else
|
|
|
1297 {
|
|
|
1298 int original_sym_value = current_sym_value;
|
|
|
1299
|
|
|
1300 /* This is the case where the parm is passed as an int or
|
|
|
1301 double and it is converted to a char, short or float
|
|
|
1302 and stored back in the parmlist. In this case, describe
|
|
|
1303 the parm with the variable's declared type, and adjust
|
|
|
1304 the address if the least significant bytes (which we are
|
|
|
1305 using) are not the first ones. */
|
|
|
1306 if (BYTES_BIG_ENDIAN
|
|
|
1307 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
|
|
|
1308 current_sym_value +=
|
|
|
1309 (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
|
|
|
1310 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
|
|
|
1311
|
|
|
1312 if (MEM_P (DECL_RTL (parms))
|
|
|
1313 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
|
|
|
1314 && (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1))
|
|
|
1315 == CONST_INT)
|
|
|
1316 && (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1))
|
|
|
1317 == current_sym_value))
|
|
|
1318 type = TREE_TYPE (parms);
|
|
|
1319 else
|
|
|
1320 {
|
|
|
1321 current_sym_value = original_sym_value;
|
|
|
1322 type = DECL_ARG_TYPE (parms);
|
|
|
1323 }
|
|
|
1324 }
|
|
|
1325
|
|
|
1326 PUT_SDB_DEF (name);
|
|
|
1327 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value, addr));
|
|
|
1328 PUT_SDB_SCL (C_ARG);
|
|
|
1329 PUT_SDB_TYPE (plain_type (type));
|
|
|
1330 PUT_SDB_ENDEF;
|
|
|
1331 }
|
|
|
1332 else if (REG_P (DECL_RTL (parms)))
|
|
|
1333 {
|
|
|
1334 rtx best_rtl;
|
|
|
1335 /* Parm passed in registers and lives in registers or nowhere. */
|
|
|
1336
|
|
|
1337 /* If parm lives in a register, use that register;
|
|
|
1338 pretend the parm was passed there. It would be more consistent
|
|
|
1339 to describe the register where the parm was passed,
|
|
|
1340 but in practice that register usually holds something else. */
|
|
|
1341 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
|
|
|
1342 best_rtl = DECL_RTL (parms);
|
|
|
1343 /* If the parm lives nowhere,
|
|
|
1344 use the register where it was passed. */
|
|
|
1345 else
|
|
|
1346 best_rtl = DECL_INCOMING_RTL (parms);
|
|
|
1347
|
|
|
1348 PUT_SDB_DEF (name);
|
|
|
1349 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (best_rtl)));
|
|
|
1350 PUT_SDB_SCL (C_REGPARM);
|
|
|
1351 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
|
|
|
1352 PUT_SDB_ENDEF;
|
|
|
1353 }
|
|
|
1354 else if (MEM_P (DECL_RTL (parms))
|
|
|
1355 && XEXP (DECL_RTL (parms), 0) != const0_rtx)
|
|
|
1356 {
|
|
|
1357 /* Parm was passed in registers but lives on the stack. */
|
|
|
1358
|
|
|
1359 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
|
|
|
1360 in which case we want the value of that CONST_INT,
|
|
|
1361 or (MEM (REG ...)) or (MEM (MEM ...)),
|
|
|
1362 in which case we use a value of zero. */
|
|
|
1363 if (REG_P (XEXP (DECL_RTL (parms), 0))
|
|
|
1364 || MEM_P (XEXP (DECL_RTL (parms), 0)))
|
|
|
1365 current_sym_value = 0;
|
|
|
1366 else
|
|
|
1367 current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
|
|
|
1368
|
|
|
1369 /* Again, this assumes the offset is based on the arg pointer. */
|
|
|
1370 PUT_SDB_DEF (name);
|
|
|
1371 PUT_SDB_INT_VAL (DEBUGGER_ARG_OFFSET (current_sym_value,
|
|
|
1372 XEXP (DECL_RTL (parms), 0)));
|
|
|
1373 PUT_SDB_SCL (C_ARG);
|
|
|
1374 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
|
|
|
1375 PUT_SDB_ENDEF;
|
|
|
1376 }
|
|
|
1377 }
|
|
|
1378 }
|
|
|
1379
|
|
|
1380 /* Output definitions for the places where parms live during the function,
|
|
|
1381 when different from where they were passed, when the parms were passed
|
|
|
1382 in memory.
|
|
|
1383
|
|
|
1384 It is not useful to do this for parms passed in registers
|
|
|
1385 that live during the function in different registers, because it is
|
|
|
1386 impossible to look in the passed register for the passed value,
|
|
|
1387 so we use the within-the-function register to begin with.
|
|
|
1388
|
|
|
1389 PARMS is a chain of PARM_DECL nodes. */
|
|
|
1390
|
|
|
1391 static void
|
|
|
1392 sdbout_reg_parms (tree parms)
|
|
|
1393 {
|
|
|
1394 for (; parms; parms = TREE_CHAIN (parms))
|
|
|
1395 if (DECL_NAME (parms))
|
|
|
1396 {
|
|
|
1397 const char *name = IDENTIFIER_POINTER (DECL_NAME (parms));
|
|
|
1398
|
|
|
1399 /* Report parms that live in registers during the function
|
|
|
1400 but were passed in memory. */
|
|
|
1401 if (REG_P (DECL_RTL (parms))
|
|
|
1402 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER
|
|
|
1403 && PARM_PASSED_IN_MEMORY (parms))
|
|
|
1404 {
|
|
|
1405 if (name == 0 || *name == 0)
|
|
|
1406 name = gen_fake_label ();
|
|
|
1407 PUT_SDB_DEF (name);
|
|
|
1408 PUT_SDB_INT_VAL (DBX_REGISTER_NUMBER (REGNO (DECL_RTL (parms))));
|
|
|
1409 PUT_SDB_SCL (C_REG);
|
|
|
1410 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
|
|
|
1411 PUT_SDB_ENDEF;
|
|
|
1412 }
|
|
|
1413 /* Report parms that live in memory but not where they were passed. */
|
|
|
1414 else if (MEM_P (DECL_RTL (parms))
|
|
|
1415 && GET_CODE (XEXP (DECL_RTL (parms), 0)) == PLUS
|
|
|
1416 && GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 1)) == CONST_INT
|
|
|
1417 && PARM_PASSED_IN_MEMORY (parms)
|
|
|
1418 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
|
|
|
1419 {
|
|
|
1420 #if 0 /* ??? It is not clear yet what should replace this. */
|
|
|
1421 int offset = DECL_OFFSET (parms) / BITS_PER_UNIT;
|
|
|
1422 /* A parm declared char is really passed as an int,
|
|
|
1423 so it occupies the least significant bytes.
|
|
|
1424 On a big-endian machine those are not the low-numbered ones. */
|
|
|
1425 if (BYTES_BIG_ENDIAN
|
|
|
1426 && offset != -1
|
|
|
1427 && TREE_TYPE (parms) != DECL_ARG_TYPE (parms))
|
|
|
1428 offset += (GET_MODE_SIZE (TYPE_MODE (DECL_ARG_TYPE (parms)))
|
|
|
1429 - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))));
|
|
|
1430 if (INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)) != offset) {...}
|
|
|
1431 #endif
|
|
|
1432 {
|
|
|
1433 if (name == 0 || *name == 0)
|
|
|
1434 name = gen_fake_label ();
|
|
|
1435 PUT_SDB_DEF (name);
|
|
|
1436 PUT_SDB_INT_VAL (DEBUGGER_AUTO_OFFSET
|
|
|
1437 (XEXP (DECL_RTL (parms), 0)));
|
|
|
1438 PUT_SDB_SCL (C_AUTO);
|
|
|
1439 PUT_SDB_TYPE (plain_type (TREE_TYPE (parms)));
|
|
|
1440 PUT_SDB_ENDEF;
|
|
|
1441 }
|
|
|
1442 }
|
|
|
1443 }
|
|
|
1444 }
|
|
|
1445
|
|
|
1446 /* Output debug information for a global DECL. Called from toplev.c
|
|
|
1447 after compilation proper has finished. */
|
|
|
1448
|
|
|
1449 static void
|
|
|
1450 sdbout_global_decl (tree decl)
|
|
|
1451 {
|
|
|
1452 if (TREE_CODE (decl) == VAR_DECL
|
|
|
1453 && !DECL_EXTERNAL (decl)
|
|
|
1454 && DECL_RTL_SET_P (decl))
|
|
|
1455 {
|
|
|
1456 /* The COFF linker can move initialized global vars to the end.
|
|
|
1457 And that can screw up the symbol ordering. Defer those for
|
|
|
1458 sdbout_finish (). */
|
|
|
1459 if (!DECL_INITIAL (decl) || !TREE_PUBLIC (decl))
|
|
|
1460 sdbout_symbol (decl, 0);
|
|
|
1461 else
|
|
|
1462 VARRAY_PUSH_TREE (deferred_global_decls, decl);
|
|
|
1463
|
|
|
1464 /* Output COFF information for non-global file-scope initialized
|
|
|
1465 variables. */
|
|
|
1466 if (DECL_INITIAL (decl) && MEM_P (DECL_RTL (decl)))
|
|
|
1467 sdbout_toplevel_data (decl);
|
|
|
1468 }
|
|
|
1469 }
|
|
|
1470
|
|
|
1471 /* Output initialized global vars at the end, in the order of
|
|
|
1472 definition. See comment in sdbout_global_decl. */
|
|
|
1473
|
|
|
1474 static void
|
|
|
1475 sdbout_finish (const char *main_filename ATTRIBUTE_UNUSED)
|
|
|
1476 {
|
|
|
1477 size_t i;
|
|
|
1478
|
|
|
1479 for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_global_decls); i++)
|
|
|
1480 sdbout_symbol (VARRAY_TREE (deferred_global_decls, i), 0);
|
|
|
1481 }
|
|
|
1482
|
|
|
1483 /* Describe the beginning of an internal block within a function.
|
|
|
1484 Also output descriptions of variables defined in this block.
|
|
|
1485
|
|
|
1486 N is the number of the block, by order of beginning, counting from 1,
|
|
|
1487 and not counting the outermost (function top-level) block.
|
|
|
1488 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
|
|
|
1489 if the count starts at 0 for the outermost one. */
|
|
|
1490
|
|
|
1491 static void
|
|
|
1492 sdbout_begin_block (unsigned int line, unsigned int n)
|
|
|
1493 {
|
|
|
1494 tree decl = current_function_decl;
|
|
|
1495 MAKE_LINE_SAFE (line);
|
|
|
1496
|
|
|
1497 /* The SCO compiler does not emit a separate block for the function level
|
|
|
1498 scope, so we avoid it here also. However, mips ECOFF compilers do emit
|
|
|
1499 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
|
|
|
1500 #ifndef MIPS_DEBUGGING_INFO
|
|
|
1501 if (n != 1)
|
|
|
1502 #endif
|
|
|
1503 PUT_SDB_BLOCK_START (line - sdb_begin_function_line);
|
|
|
1504
|
|
|
1505 if (n == 1)
|
|
|
1506 {
|
|
|
1507 /* Include the outermost BLOCK's variables in block 1. */
|
|
|
1508 do_block = BLOCK_NUMBER (DECL_INITIAL (decl));
|
|
|
1509 sdbout_block (DECL_INITIAL (decl));
|
|
|
1510 }
|
|
|
1511 /* If -g1, suppress all the internal symbols of functions
|
|
|
1512 except for arguments. */
|
|
|
1513 if (debug_info_level != DINFO_LEVEL_TERSE)
|
|
|
1514 {
|
|
|
1515 do_block = n;
|
|
|
1516 sdbout_block (DECL_INITIAL (decl));
|
|
|
1517 }
|
|
|
1518
|
|
|
1519 #ifdef SDB_ALLOW_FORWARD_REFERENCES
|
|
|
1520 sdbout_dequeue_anonymous_types ();
|
|
|
1521 #endif
|
|
|
1522 }
|
|
|
1523
|
|
|
1524 /* Describe the end line-number of an internal block within a function. */
|
|
|
1525
|
|
|
1526 static void
|
|
|
1527 sdbout_end_block (unsigned int line, unsigned int n ATTRIBUTE_UNUSED)
|
|
|
1528 {
|
|
|
1529 MAKE_LINE_SAFE (line);
|
|
|
1530
|
|
|
1531 /* The SCO compiler does not emit a separate block for the function level
|
|
|
1532 scope, so we avoid it here also. However, mips ECOFF compilers do emit
|
|
|
1533 a separate block, so we retain it when MIPS_DEBUGGING_INFO is defined. */
|
|
|
1534 #ifndef MIPS_DEBUGGING_INFO
|
|
|
1535 if (n != 1)
|
|
|
1536 #endif
|
|
|
1537 PUT_SDB_BLOCK_END (line - sdb_begin_function_line);
|
|
|
1538 }
|
|
|
1539
|
|
|
1540 /* Output a line number symbol entry for source file FILENAME and line
|
|
|
1541 number LINE. */
|
|
|
1542
|
|
|
1543 static void
|
|
|
1544 sdbout_source_line (unsigned int line, const char *filename ATTRIBUTE_UNUSED)
|
|
|
1545 {
|
|
|
1546 /* COFF relative line numbers must be positive. */
|
|
|
1547 if ((int) line > sdb_begin_function_line)
|
|
|
1548 {
|
|
|
1549 #ifdef SDB_OUTPUT_SOURCE_LINE
|
|
|
1550 SDB_OUTPUT_SOURCE_LINE (asm_out_file, line);
|
|
|
1551 #else
|
|
|
1552 fprintf (asm_out_file, "\t.ln\t%d\n",
|
|
|
1553 ((sdb_begin_function_line > -1)
|
|
|
1554 ? line - sdb_begin_function_line : 1));
|
|
|
1555 #endif
|
|
|
1556 }
|
|
|
1557 }
|
|
|
1558
|
|
|
1559 /* Output sdb info for the current function name.
|
|
|
1560 Called from assemble_start_function. */
|
|
|
1561
|
|
|
1562 static void
|
|
|
1563 sdbout_begin_function (tree decl ATTRIBUTE_UNUSED)
|
|
|
1564 {
|
|
|
1565 sdbout_symbol (current_function_decl, 0);
|
|
|
1566 }
|
|
|
1567
|
|
|
1568 /* Called at beginning of function body (before or after prologue,
|
|
|
1569 depending on MIPS_DEBUGGING_INFO). Record the function's starting
|
|
|
1570 line number, so we can output relative line numbers for the other
|
|
|
1571 lines. Describe beginning of outermost block. Also describe the
|
|
|
1572 parameter list. */
|
|
|
1573
|
|
|
1574 #ifndef MIPS_DEBUGGING_INFO
|
|
|
1575 static void
|
|
|
1576 sdbout_begin_prologue (unsigned int line, const char *file ATTRIBUTE_UNUSED)
|
|
|
1577 {
|
|
|
1578 sdbout_end_prologue (line, file);
|
|
|
1579 }
|
|
|
1580 #endif
|
|
|
1581
|
|
|
1582 static void
|
|
|
1583 sdbout_end_prologue (unsigned int line, const char *file ATTRIBUTE_UNUSED)
|
|
|
1584 {
|
|
|
1585 sdb_begin_function_line = line - 1;
|
|
|
1586 PUT_SDB_FUNCTION_START (line);
|
|
|
1587 sdbout_parms (DECL_ARGUMENTS (current_function_decl));
|
|
|
1588 sdbout_reg_parms (DECL_ARGUMENTS (current_function_decl));
|
|
|
1589 }
|
|
|
1590
|
|
|
1591 /* Called at end of function (before epilogue).
|
|
|
1592 Describe end of outermost block. */
|
|
|
1593
|
|
|
1594 static void
|
|
|
1595 sdbout_end_function (unsigned int line)
|
|
|
1596 {
|
|
|
1597 #ifdef SDB_ALLOW_FORWARD_REFERENCES
|
|
|
1598 sdbout_dequeue_anonymous_types ();
|
|
|
1599 #endif
|
|
|
1600
|
|
|
1601 MAKE_LINE_SAFE (line);
|
|
|
1602 PUT_SDB_FUNCTION_END (line - sdb_begin_function_line);
|
|
|
1603
|
|
|
1604 /* Indicate we are between functions, for line-number output. */
|
|
|
1605 sdb_begin_function_line = -1;
|
|
|
1606 }
|
|
|
1607
|
|
|
1608 /* Output sdb info for the absolute end of a function.
|
|
|
1609 Called after the epilogue is output. */
|
|
|
1610
|
|
|
1611 static void
|
|
|
1612 sdbout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
|
|
|
1613 const char *file ATTRIBUTE_UNUSED)
|
|
|
1614 {
|
|
|
1615 const char *const name ATTRIBUTE_UNUSED
|
|
|
1616 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl));
|
|
|
1617
|
|
|
1618 #ifdef PUT_SDB_EPILOGUE_END
|
|
|
1619 PUT_SDB_EPILOGUE_END (name);
|
|
|
1620 #else
|
|
|
1621 fprintf (asm_out_file, "\t.def\t");
|
|
|
1622 assemble_name (asm_out_file, name);
|
|
|
1623 fprintf (asm_out_file, "%s\t.val\t.%s\t.scl\t-1%s\t.endef\n",
|
|
|
1624 SDB_DELIM, SDB_DELIM, SDB_DELIM);
|
|
|
1625 #endif
|
|
|
1626 }
|
|
|
1627
|
|
|
1628 /* Output sdb info for the given label. Called only if LABEL_NAME (insn)
|
|
|
1629 is present. */
|
|
|
1630
|
|
|
1631 static void
|
|
|
1632 sdbout_label (rtx insn)
|
|
|
1633 {
|
|
|
1634 PUT_SDB_DEF (LABEL_NAME (insn));
|
|
|
1635 PUT_SDB_VAL (insn);
|
|
|
1636 PUT_SDB_SCL (C_LABEL);
|
|
|
1637 PUT_SDB_TYPE (T_NULL);
|
|
|
1638 PUT_SDB_ENDEF;
|
|
|
1639 }
|
|
|
1640
|
|
|
1641 /* Change to reading from a new source file. */
|
|
|
1642
|
|
|
1643 static void
|
|
|
1644 sdbout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
|
|
|
1645 const char *filename ATTRIBUTE_UNUSED)
|
|
|
1646 {
|
|
|
1647 #ifdef MIPS_DEBUGGING_INFO
|
|
|
1648 struct sdb_file *n = XNEW (struct sdb_file);
|
|
|
1649
|
|
|
1650 n->next = current_file;
|
|
|
1651 n->name = filename;
|
|
|
1652 current_file = n;
|
|
|
1653 output_file_directive (asm_out_file, filename);
|
|
|
1654 #endif
|
|
|
1655 }
|
|
|
1656
|
|
|
1657 /* Revert to reading a previous source file. */
|
|
|
1658
|
|
|
1659 static void
|
|
|
1660 sdbout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
|
|
|
1661 {
|
|
|
1662 #ifdef MIPS_DEBUGGING_INFO
|
|
|
1663 struct sdb_file *next;
|
|
|
1664
|
|
|
1665 next = current_file->next;
|
|
|
1666 free (current_file);
|
|
|
1667 current_file = next;
|
|
|
1668 output_file_directive (asm_out_file, current_file->name);
|
|
|
1669 #endif
|
|
|
1670 }
|
|
|
1671
|
|
|
1672 /* Set up for SDB output at the start of compilation. */
|
|
|
1673
|
|
|
1674 static void
|
|
|
1675 sdbout_init (const char *input_file_name ATTRIBUTE_UNUSED)
|
|
|
1676 {
|
|
|
1677 tree t;
|
|
|
1678
|
|
|
1679 #ifdef MIPS_DEBUGGING_INFO
|
|
|
1680 current_file = XNEW (struct sdb_file);
|
|
|
1681 current_file->next = NULL;
|
|
|
1682 current_file->name = input_file_name;
|
|
|
1683 #endif
|
|
|
1684
|
|
|
1685 VARRAY_TREE_INIT (deferred_global_decls, 12, "deferred_global_decls");
|
|
|
1686
|
|
|
1687 /* Emit debug information which was queued by sdbout_symbol before
|
|
|
1688 we got here. */
|
|
|
1689 sdbout_initialized = true;
|
|
|
1690
|
|
|
1691 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
|
|
|
1692 sdbout_symbol (TREE_VALUE (t), 0);
|
|
|
1693 preinit_symbols = 0;
|
|
|
1694 }
|
|
|
1695
|
|
|
1696 #else /* SDB_DEBUGGING_INFO */
|
|
|
1697
|
|
|
1698 /* This should never be used, but its address is needed for comparisons. */
|
|
|
1699 const struct gcc_debug_hooks sdb_debug_hooks;
|
|
|
1700
|
|
|
1701 #endif /* SDB_DEBUGGING_INFO */
|
|
|
1702
|
|
|
1703 #include "gt-sdbout.h"
|
