|
0
|
1 /* Output xcoff-format symbol table information from GNU compiler.
|
|
|
2 Copyright (C) 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 2004,
|
|
|
3 2007, 2008 Free Software Foundation, Inc.
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 /* Output xcoff-format symbol table data. The main functionality is contained
|
|
|
22 in dbxout.c. This file implements the sdbout-like parts of the xcoff
|
|
|
23 interface. Many functions are very similar to their counterparts in
|
|
|
24 sdbout.c. */
|
|
|
25
|
|
|
26 #include "config.h"
|
|
|
27 #include "system.h"
|
|
|
28 #include "coretypes.h"
|
|
|
29 #include "tm.h"
|
|
|
30 #include "tree.h"
|
|
|
31 #include "rtl.h"
|
|
|
32 #include "flags.h"
|
|
|
33 #include "toplev.h"
|
|
|
34 #include "output.h"
|
|
|
35 #include "ggc.h"
|
|
|
36 #include "target.h"
|
|
|
37 #include "debug.h"
|
|
|
38
|
|
|
39 #ifdef XCOFF_DEBUGGING_INFO
|
|
|
40
|
|
|
41 /* This defines the C_* storage classes. */
|
|
|
42 #include "xcoff.h"
|
|
|
43 #include "xcoffout.h"
|
|
|
44 #include "dbxout.h"
|
|
|
45 #include "gstab.h"
|
|
|
46
|
|
|
47 /* Line number of beginning of current function, minus one.
|
|
|
48 Negative means not in a function or not using xcoff. */
|
|
|
49
|
|
|
50 static int xcoff_begin_function_line = -1;
|
|
|
51 static int xcoff_inlining = 0;
|
|
|
52
|
|
|
53 /* Name of the current include file. */
|
|
|
54
|
|
|
55 const char *xcoff_current_include_file;
|
|
|
56
|
|
|
57 /* Name of the current function file. This is the file the `.bf' is
|
|
|
58 emitted from. In case a line is emitted from a different file,
|
|
|
59 (by including that file of course), then the line number will be
|
|
|
60 absolute. */
|
|
|
61
|
|
|
62 static const char *xcoff_current_function_file;
|
|
|
63
|
|
|
64 /* Names of bss and data sections. These should be unique names for each
|
|
|
65 compilation unit. */
|
|
|
66
|
|
|
67 char *xcoff_bss_section_name;
|
|
|
68 char *xcoff_private_data_section_name;
|
|
|
69 char *xcoff_read_only_section_name;
|
|
|
70
|
|
|
71 /* Last source file name mentioned in a NOTE insn. */
|
|
|
72
|
|
|
73 const char *xcoff_lastfile;
|
|
|
74
|
|
|
75 /* Macro definitions used below. */
|
|
|
76
|
|
|
77 #define ABS_OR_RELATIVE_LINENO(LINENO) \
|
|
|
78 ((xcoff_inlining) ? (LINENO) : (LINENO) - xcoff_begin_function_line)
|
|
|
79
|
|
|
80 /* Output source line numbers via ".line". */
|
|
|
81 #define ASM_OUTPUT_LINE(FILE,LINENUM) \
|
|
|
82 do \
|
|
|
83 { \
|
|
|
84 if (xcoff_begin_function_line >= 0) \
|
|
|
85 fprintf (FILE, "\t.line\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM)); \
|
|
|
86 } \
|
|
|
87 while (0)
|
|
|
88
|
|
|
89 #define ASM_OUTPUT_LFB(FILE,LINENUM) \
|
|
|
90 { \
|
|
|
91 if (xcoff_begin_function_line == -1) \
|
|
|
92 { \
|
|
|
93 xcoff_begin_function_line = (LINENUM) - 1;\
|
|
|
94 fprintf (FILE, "\t.bf\t%d\n", (LINENUM)); \
|
|
|
95 } \
|
|
|
96 xcoff_current_function_file \
|
|
|
97 = (xcoff_current_include_file \
|
|
|
98 ? xcoff_current_include_file : main_input_filename); \
|
|
|
99 }
|
|
|
100
|
|
|
101 #define ASM_OUTPUT_LFE(FILE,LINENUM) \
|
|
|
102 do \
|
|
|
103 { \
|
|
|
104 fprintf (FILE, "\t.ef\t%d\n", (LINENUM)); \
|
|
|
105 xcoff_begin_function_line = -1; \
|
|
|
106 } \
|
|
|
107 while (0)
|
|
|
108
|
|
|
109 #define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
|
|
|
110 fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
|
|
|
111
|
|
|
112 #define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
|
|
|
113 fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
|
|
|
114
|
|
|
115 static void xcoffout_block (tree, int, tree);
|
|
|
116 static void xcoffout_source_file (FILE *, const char *, int);
|
|
|
117
|
|
|
118 /* Support routines for XCOFF debugging info. */
|
|
|
119
|
|
|
120 struct xcoff_type_number
|
|
|
121 {
|
|
|
122 const char *name;
|
|
|
123 int number;
|
|
|
124 };
|
|
|
125 static const struct xcoff_type_number xcoff_type_numbers[] = {
|
|
|
126 { "int", -1 },
|
|
|
127 { "char", -2 },
|
|
|
128 { "short int", -3 },
|
|
|
129 { "long int", -4 }, /* fiddled to -31 if 64 bits */
|
|
|
130 { "unsigned char", -5 },
|
|
|
131 { "signed char", -6 },
|
|
|
132 { "short unsigned int", -7 },
|
|
|
133 { "unsigned int", -8 },
|
|
|
134 /* No such type "unsigned". */
|
|
|
135 { "long unsigned int", -10 }, /* fiddled to -32 if 64 bits */
|
|
|
136 { "void", -11 },
|
|
|
137 { "float", -12 },
|
|
|
138 { "double", -13 },
|
|
|
139 { "long double", -14 },
|
|
|
140 /* Pascal and Fortran types run from -15 to -29. */
|
|
|
141 { "wchar", -30 }, /* XXX Should be "wchar_t" ? */
|
|
|
142 { "long long int", -31 },
|
|
|
143 { "long long unsigned int", -32 },
|
|
|
144 /* Additional Fortran types run from -33 to -37. */
|
|
|
145
|
|
|
146 /* ??? Should also handle built-in C++ and Obj-C types. There perhaps
|
|
|
147 aren't any that C doesn't already have. */
|
|
|
148 };
|
|
|
149
|
|
|
150 /* Returns an XCOFF fundamental type number for DECL (assumed to be a
|
|
|
151 TYPE_DECL), or 0 if dbxout.c should assign a type number normally. */
|
|
|
152 int
|
|
|
153 xcoff_assign_fundamental_type_number (tree decl)
|
|
|
154 {
|
|
|
155 const char *name;
|
|
|
156 size_t i;
|
|
|
157
|
|
|
158 /* Do not waste time searching the list for non-intrinsic types. */
|
|
|
159 if (DECL_NAME (decl) == 0 || ! DECL_IS_BUILTIN (decl))
|
|
|
160 return 0;
|
|
|
161
|
|
|
162 name = IDENTIFIER_POINTER (DECL_NAME (decl));
|
|
|
163
|
|
|
164 /* Linear search, blech, but the list is too small to bother
|
|
|
165 doing anything else. */
|
|
|
166 for (i = 0; i < ARRAY_SIZE (xcoff_type_numbers); i++)
|
|
|
167 if (!strcmp (xcoff_type_numbers[i].name, name))
|
|
|
168 goto found;
|
|
|
169 return 0;
|
|
|
170
|
|
|
171 found:
|
|
|
172 /* -4 and -10 should be replaced with -31 and -32, respectively,
|
|
|
173 when used for a 64-bit type. */
|
|
|
174 if (int_size_in_bytes (TREE_TYPE (decl)) == 8)
|
|
|
175 {
|
|
|
176 if (xcoff_type_numbers[i].number == -4)
|
|
|
177 return -31;
|
|
|
178 if (xcoff_type_numbers[i].number == -10)
|
|
|
179 return -32;
|
|
|
180 }
|
|
|
181 return xcoff_type_numbers[i].number;
|
|
|
182 }
|
|
|
183
|
|
|
184 /* Print an error message for unrecognized stab codes. */
|
|
|
185
|
|
|
186 #define UNKNOWN_STAB(STR) \
|
|
|
187 internal_error ("no sclass for %s stab (0x%x)", STR, stab)
|
|
|
188
|
|
|
189 /* Conversion routine from BSD stabs to AIX storage classes. */
|
|
|
190
|
|
|
191 int
|
|
|
192 stab_to_sclass (int stab)
|
|
|
193 {
|
|
|
194 switch (stab)
|
|
|
195 {
|
|
|
196 case N_GSYM:
|
|
|
197 return C_GSYM;
|
|
|
198
|
|
|
199 case N_FNAME:
|
|
|
200 UNKNOWN_STAB ("N_FNAME");
|
|
|
201
|
|
|
202 case N_FUN:
|
|
|
203 return C_FUN;
|
|
|
204
|
|
|
205 case N_STSYM:
|
|
|
206 case N_LCSYM:
|
|
|
207 return C_STSYM;
|
|
|
208
|
|
|
209 case N_MAIN:
|
|
|
210 UNKNOWN_STAB ("N_MAIN");
|
|
|
211
|
|
|
212 case N_RSYM:
|
|
|
213 return C_RSYM;
|
|
|
214
|
|
|
215 case N_SSYM:
|
|
|
216 UNKNOWN_STAB ("N_SSYM");
|
|
|
217
|
|
|
218 case N_RPSYM:
|
|
|
219 return C_RPSYM;
|
|
|
220
|
|
|
221 case N_PSYM:
|
|
|
222 return C_PSYM;
|
|
|
223 case N_LSYM:
|
|
|
224 return C_LSYM;
|
|
|
225 case N_DECL:
|
|
|
226 return C_DECL;
|
|
|
227 case N_ENTRY:
|
|
|
228 return C_ENTRY;
|
|
|
229
|
|
|
230 case N_SO:
|
|
|
231 UNKNOWN_STAB ("N_SO");
|
|
|
232
|
|
|
233 case N_SOL:
|
|
|
234 UNKNOWN_STAB ("N_SOL");
|
|
|
235
|
|
|
236 case N_SLINE:
|
|
|
237 UNKNOWN_STAB ("N_SLINE");
|
|
|
238
|
|
|
239 case N_DSLINE:
|
|
|
240 UNKNOWN_STAB ("N_DSLINE");
|
|
|
241
|
|
|
242 case N_BSLINE:
|
|
|
243 UNKNOWN_STAB ("N_BSLINE");
|
|
|
244
|
|
|
245 case N_BINCL:
|
|
|
246 UNKNOWN_STAB ("N_BINCL");
|
|
|
247
|
|
|
248 case N_EINCL:
|
|
|
249 UNKNOWN_STAB ("N_EINCL");
|
|
|
250
|
|
|
251 case N_EXCL:
|
|
|
252 UNKNOWN_STAB ("N_EXCL");
|
|
|
253
|
|
|
254 case N_LBRAC:
|
|
|
255 UNKNOWN_STAB ("N_LBRAC");
|
|
|
256
|
|
|
257 case N_RBRAC:
|
|
|
258 UNKNOWN_STAB ("N_RBRAC");
|
|
|
259
|
|
|
260 case N_BCOMM:
|
|
|
261 return C_BCOMM;
|
|
|
262 case N_ECOMM:
|
|
|
263 return C_ECOMM;
|
|
|
264 case N_ECOML:
|
|
|
265 return C_ECOML;
|
|
|
266
|
|
|
267 case N_LENG:
|
|
|
268 UNKNOWN_STAB ("N_LENG");
|
|
|
269
|
|
|
270 case N_PC:
|
|
|
271 UNKNOWN_STAB ("N_PC");
|
|
|
272
|
|
|
273 case N_M2C:
|
|
|
274 UNKNOWN_STAB ("N_M2C");
|
|
|
275
|
|
|
276 case N_SCOPE:
|
|
|
277 UNKNOWN_STAB ("N_SCOPE");
|
|
|
278
|
|
|
279 case N_CATCH:
|
|
|
280 UNKNOWN_STAB ("N_CATCH");
|
|
|
281
|
|
|
282 case N_OPT:
|
|
|
283 UNKNOWN_STAB ("N_OPT");
|
|
|
284
|
|
|
285 default:
|
|
|
286 UNKNOWN_STAB ("?");
|
|
|
287 }
|
|
|
288 }
|
|
|
289
|
|
|
290 /* Output debugging info to FILE to switch to sourcefile FILENAME.
|
|
|
291 INLINE_P is true if this is from an inlined function. */
|
|
|
292
|
|
|
293 static void
|
|
|
294 xcoffout_source_file (FILE *file, const char *filename, int inline_p)
|
|
|
295 {
|
|
|
296 if (filename
|
|
|
297 && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
|
|
|
298 || (inline_p && ! xcoff_inlining)
|
|
|
299 || (! inline_p && xcoff_inlining)))
|
|
|
300 {
|
|
|
301 if (xcoff_current_include_file)
|
|
|
302 {
|
|
|
303 fprintf (file, "\t.ei\t");
|
|
|
304 output_quoted_string (file,
|
|
|
305 remap_debug_filename (xcoff_current_include_file));
|
|
|
306 fprintf (file, "\n");
|
|
|
307 xcoff_current_include_file = NULL;
|
|
|
308 }
|
|
|
309 xcoff_inlining = inline_p;
|
|
|
310 if (strcmp (main_input_filename, filename) || inline_p)
|
|
|
311 {
|
|
|
312 fprintf (file, "\t.bi\t");
|
|
|
313 output_quoted_string (file, remap_debug_filename (filename));
|
|
|
314 fprintf (file, "\n");
|
|
|
315 xcoff_current_include_file = filename;
|
|
|
316 }
|
|
|
317 xcoff_lastfile = filename;
|
|
|
318 }
|
|
|
319 }
|
|
|
320
|
|
|
321 /* Output a line number symbol entry for location (FILENAME, LINE). */
|
|
|
322
|
|
|
323 void
|
|
|
324 xcoffout_source_line (unsigned int line, const char *filename)
|
|
|
325 {
|
|
|
326 bool inline_p = (strcmp (xcoff_current_function_file, filename) != 0
|
|
|
327 || (int) line < xcoff_begin_function_line);
|
|
|
328
|
|
|
329 xcoffout_source_file (asm_out_file, filename, inline_p);
|
|
|
330
|
|
|
331 ASM_OUTPUT_LINE (asm_out_file, line);
|
|
|
332 }
|
|
|
333
|
|
|
334 /* Output the symbols defined in block number DO_BLOCK.
|
|
|
335
|
|
|
336 This function works by walking the tree structure of blocks,
|
|
|
337 counting blocks until it finds the desired block. */
|
|
|
338
|
|
|
339 static int do_block = 0;
|
|
|
340
|
|
|
341 static void
|
|
|
342 xcoffout_block (tree block, int depth, tree args)
|
|
|
343 {
|
|
|
344 while (block)
|
|
|
345 {
|
|
|
346 /* Ignore blocks never expanded or otherwise marked as real. */
|
|
|
347 if (TREE_USED (block))
|
|
|
348 {
|
|
|
349 /* When we reach the specified block, output its symbols. */
|
|
|
350 if (BLOCK_NUMBER (block) == do_block)
|
|
|
351 {
|
|
|
352 /* Output the syms of the block. */
|
|
|
353 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
|
|
|
354 dbxout_syms (BLOCK_VARS (block));
|
|
|
355 if (args)
|
|
|
356 dbxout_reg_parms (args);
|
|
|
357
|
|
|
358 /* We are now done with the block. Don't go to inner blocks. */
|
|
|
359 return;
|
|
|
360 }
|
|
|
361 /* If we are past the specified block, stop the scan. */
|
|
|
362 else if (BLOCK_NUMBER (block) >= do_block)
|
|
|
363 return;
|
|
|
364
|
|
|
365 /* Output the subblocks. */
|
|
|
366 xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
|
|
|
367 }
|
|
|
368 block = BLOCK_CHAIN (block);
|
|
|
369 }
|
|
|
370 }
|
|
|
371
|
|
|
372 /* Describe the beginning of an internal block within a function.
|
|
|
373 Also output descriptions of variables defined in this block.
|
|
|
374
|
|
|
375 N is the number of the block, by order of beginning, counting from 1,
|
|
|
376 and not counting the outermost (function top-level) block.
|
|
|
377 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
|
|
|
378 if the count starts at 0 for the outermost one. */
|
|
|
379
|
|
|
380 void
|
|
|
381 xcoffout_begin_block (unsigned int line, unsigned int n)
|
|
|
382 {
|
|
|
383 tree decl = current_function_decl;
|
|
|
384
|
|
|
385 /* The IBM AIX compiler does not emit a .bb for the function level scope,
|
|
|
386 so we avoid it here also. */
|
|
|
387 if (n != 1)
|
|
|
388 ASM_OUTPUT_LBB (asm_out_file, line, n);
|
|
|
389
|
|
|
390 do_block = n;
|
|
|
391 xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
|
|
|
392 }
|
|
|
393
|
|
|
394 /* Describe the end line-number of an internal block within a function. */
|
|
|
395
|
|
|
396 void
|
|
|
397 xcoffout_end_block (unsigned int line, unsigned int n)
|
|
|
398 {
|
|
|
399 if (n != 1)
|
|
|
400 ASM_OUTPUT_LBE (asm_out_file, line, n);
|
|
|
401 }
|
|
|
402
|
|
|
403 /* Called at beginning of function (before prologue).
|
|
|
404 Declare function as needed for debugging. */
|
|
|
405
|
|
|
406 void
|
|
|
407 xcoffout_declare_function (FILE *file, tree decl, const char *name)
|
|
|
408 {
|
|
|
409 size_t len;
|
|
|
410
|
|
|
411 if (*name == '*')
|
|
|
412 name++;
|
|
|
413 len = strlen (name);
|
|
|
414 if (name[len - 1] == ']')
|
|
|
415 {
|
|
|
416 char *n = XALLOCAVEC (char, len - 3);
|
|
|
417 memcpy (n, name, len - 4);
|
|
|
418 n[len - 4] = '\0';
|
|
|
419 name = n;
|
|
|
420 }
|
|
|
421
|
|
|
422 /* Any pending .bi or .ei must occur before the .function pseudo op.
|
|
|
423 Otherwise debuggers will think that the function is in the previous
|
|
|
424 file and/or at the wrong line number. */
|
|
|
425 xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
|
|
|
426 dbxout_symbol (decl, 0);
|
|
|
427
|
|
|
428 /* .function NAME, TOP, MAPPING, TYPE, SIZE
|
|
|
429 16 and 044 are placeholders for backwards compatibility */
|
|
|
430 fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
|
|
|
431 name, name, name, name);
|
|
|
432 }
|
|
|
433
|
|
|
434 /* Called at beginning of function body (at start of prologue).
|
|
|
435 Record the function's starting line number, so we can output
|
|
|
436 relative line numbers for the other lines.
|
|
|
437 Record the file name that this function is contained in. */
|
|
|
438
|
|
|
439 void
|
|
|
440 xcoffout_begin_prologue (unsigned int line,
|
|
|
441 const char *file ATTRIBUTE_UNUSED)
|
|
|
442 {
|
|
|
443 ASM_OUTPUT_LFB (asm_out_file, line);
|
|
|
444 dbxout_parms (DECL_ARGUMENTS (current_function_decl));
|
|
|
445
|
|
|
446 /* Emit the symbols for the outermost BLOCK's variables. sdbout.c does this
|
|
|
447 in sdbout_begin_block, but there is no guarantee that there will be any
|
|
|
448 inner block 1, so we must do it here. This gives a result similar to
|
|
|
449 dbxout, so it does make some sense. */
|
|
|
450 do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
|
|
|
451 xcoffout_block (DECL_INITIAL (current_function_decl), 0,
|
|
|
452 DECL_ARGUMENTS (current_function_decl));
|
|
|
453
|
|
|
454 ASM_OUTPUT_LINE (asm_out_file, line);
|
|
|
455 }
|
|
|
456
|
|
|
457 /* Called at end of function (before epilogue).
|
|
|
458 Describe end of outermost block. */
|
|
|
459
|
|
|
460 void
|
|
|
461 xcoffout_end_function (unsigned int last_linenum)
|
|
|
462 {
|
|
|
463 ASM_OUTPUT_LFE (asm_out_file, last_linenum);
|
|
|
464 }
|
|
|
465
|
|
|
466 /* Output xcoff info for the absolute end of a function.
|
|
|
467 Called after the epilogue is output. */
|
|
|
468
|
|
|
469 void
|
|
|
470 xcoffout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
|
|
|
471 const char *file ATTRIBUTE_UNUSED)
|
|
|
472 {
|
|
|
473 /* We need to pass the correct function size to .function, otherwise,
|
|
|
474 the xas assembler can't figure out the correct size for the function
|
|
|
475 aux entry. So, we emit a label after the last instruction which can
|
|
|
476 be used by the .function pseudo op to calculate the function size. */
|
|
|
477
|
|
|
478 const char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
|
|
|
479 if (*fname == '*')
|
|
|
480 ++fname;
|
|
|
481 fprintf (asm_out_file, "FE..");
|
|
|
482 ASM_OUTPUT_LABEL (asm_out_file, fname);
|
|
|
483 }
|
|
|
484 #endif /* XCOFF_DEBUGGING_INFO */
|
