1 /* Output xcoff-format symbol table information from GNU compiler.
2 Copyright (C) 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 2004
3 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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 /* Output xcoff-format symbol table data. The main functionality is contained
23 in dbxout.c. This file implements the sdbout-like parts of the xcoff
24 interface. Many functions are very similar to their counterparts in
25 sdbout.c. */
26
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "tree.h"
32 #include "rtl.h"
33 #include "flags.h"
34 #include "toplev.h"
35 #include "output.h"
36 #include "ggc.h"
37 #include "target.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
xcoff_assign_fundamental_type_number(tree decl)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
stab_to_sclass(int stab)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
xcoffout_source_file(FILE * file,const char * filename,int inline_p)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, xcoff_current_include_file);
305 fprintf (file, "\n");
306 xcoff_current_include_file = NULL;
307 }
308 xcoff_inlining = inline_p;
309 if (strcmp (main_input_filename, filename) || inline_p)
310 {
311 fprintf (file, "\t.bi\t");
312 output_quoted_string (file, filename);
313 fprintf (file, "\n");
314 xcoff_current_include_file = filename;
315 }
316 xcoff_lastfile = filename;
317 }
318 }
319
320 /* Output a line number symbol entry for location (FILENAME, LINE). */
321
322 void
xcoffout_source_line(unsigned int line,const char * filename)323 xcoffout_source_line (unsigned int line, const char *filename)
324 {
325 bool inline_p = (strcmp (xcoff_current_function_file, filename) != 0
326 || (int) line < xcoff_begin_function_line);
327
328 xcoffout_source_file (asm_out_file, filename, inline_p);
329
330 ASM_OUTPUT_LINE (asm_out_file, line);
331 }
332
333 /* Output the symbols defined in block number DO_BLOCK.
334
335 This function works by walking the tree structure of blocks,
336 counting blocks until it finds the desired block. */
337
338 static int do_block = 0;
339
340 static void
xcoffout_block(tree block,int depth,tree args)341 xcoffout_block (tree block, int depth, tree args)
342 {
343 while (block)
344 {
345 /* Ignore blocks never expanded or otherwise marked as real. */
346 if (TREE_USED (block))
347 {
348 /* When we reach the specified block, output its symbols. */
349 if (BLOCK_NUMBER (block) == do_block)
350 {
351 /* Output the syms of the block. */
352 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
353 dbxout_syms (BLOCK_VARS (block));
354 if (args)
355 dbxout_reg_parms (args);
356
357 /* We are now done with the block. Don't go to inner blocks. */
358 return;
359 }
360 /* If we are past the specified block, stop the scan. */
361 else if (BLOCK_NUMBER (block) >= do_block)
362 return;
363
364 /* Output the subblocks. */
365 xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
366 }
367 block = BLOCK_CHAIN (block);
368 }
369 }
370
371 /* Describe the beginning of an internal block within a function.
372 Also output descriptions of variables defined in this block.
373
374 N is the number of the block, by order of beginning, counting from 1,
375 and not counting the outermost (function top-level) block.
376 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
377 if the count starts at 0 for the outermost one. */
378
379 void
xcoffout_begin_block(unsigned int line,unsigned int n)380 xcoffout_begin_block (unsigned int line, unsigned int n)
381 {
382 tree decl = current_function_decl;
383
384 /* The IBM AIX compiler does not emit a .bb for the function level scope,
385 so we avoid it here also. */
386 if (n != 1)
387 ASM_OUTPUT_LBB (asm_out_file, line, n);
388
389 do_block = n;
390 xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
391 }
392
393 /* Describe the end line-number of an internal block within a function. */
394
395 void
xcoffout_end_block(unsigned int line,unsigned int n)396 xcoffout_end_block (unsigned int line, unsigned int n)
397 {
398 if (n != 1)
399 ASM_OUTPUT_LBE (asm_out_file, line, n);
400 }
401
402 /* Called at beginning of function (before prologue).
403 Declare function as needed for debugging. */
404
405 void
xcoffout_declare_function(FILE * file,tree decl,const char * name)406 xcoffout_declare_function (FILE *file, tree decl, const char *name)
407 {
408 size_t len;
409
410 if (*name == '*')
411 name++;
412 len = strlen (name);
413 if (name[len - 1] == ']')
414 {
415 char *n = alloca (len - 3);
416 memcpy (n, name, len - 4);
417 n[len - 4] = '\0';
418 name = n;
419 }
420
421 /* Any pending .bi or .ei must occur before the .function pseudo op.
422 Otherwise debuggers will think that the function is in the previous
423 file and/or at the wrong line number. */
424 xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
425 dbxout_symbol (decl, 0);
426
427 /* .function NAME, TOP, MAPPING, TYPE, SIZE
428 16 and 044 are placeholders for backwards compatibility */
429 fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
430 name, name, name, name);
431 }
432
433 /* Called at beginning of function body (at start of prologue).
434 Record the function's starting line number, so we can output
435 relative line numbers for the other lines.
436 Record the file name that this function is contained in. */
437
438 void
xcoffout_begin_prologue(unsigned int line,const char * file ATTRIBUTE_UNUSED)439 xcoffout_begin_prologue (unsigned int line,
440 const char *file ATTRIBUTE_UNUSED)
441 {
442 ASM_OUTPUT_LFB (asm_out_file, line);
443 dbxout_parms (DECL_ARGUMENTS (current_function_decl));
444
445 /* Emit the symbols for the outermost BLOCK's variables. sdbout.c does this
446 in sdbout_begin_block, but there is no guarantee that there will be any
447 inner block 1, so we must do it here. This gives a result similar to
448 dbxout, so it does make some sense. */
449 do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
450 xcoffout_block (DECL_INITIAL (current_function_decl), 0,
451 DECL_ARGUMENTS (current_function_decl));
452
453 ASM_OUTPUT_LINE (asm_out_file, line);
454 }
455
456 /* Called at end of function (before epilogue).
457 Describe end of outermost block. */
458
459 void
xcoffout_end_function(unsigned int last_linenum)460 xcoffout_end_function (unsigned int last_linenum)
461 {
462 ASM_OUTPUT_LFE (asm_out_file, last_linenum);
463 }
464
465 /* Output xcoff info for the absolute end of a function.
466 Called after the epilogue is output. */
467
468 void
xcoffout_end_epilogue(unsigned int line ATTRIBUTE_UNUSED,const char * file ATTRIBUTE_UNUSED)469 xcoffout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
470 const char *file ATTRIBUTE_UNUSED)
471 {
472 /* We need to pass the correct function size to .function, otherwise,
473 the xas assembler can't figure out the correct size for the function
474 aux entry. So, we emit a label after the last instruction which can
475 be used by the .function pseudo op to calculate the function size. */
476
477 const char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
478 if (*fname == '*')
479 ++fname;
480 fprintf (asm_out_file, "FE..");
481 ASM_OUTPUT_LABEL (asm_out_file, fname);
482 }
483 #endif /* XCOFF_DEBUGGING_INFO */
484