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