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