1 /* Output xcoff-format symbol table information from GNU compiler.
2 Copyright (C) 1992, 1994, 1995, 1997, 1998, 1999, 2000
3 Free Software Foundation, Inc.
5 This file is part of GCC.
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
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
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
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
36 #ifdef XCOFF_DEBUGGING_INFO
38 /* This defines the C_* storage classes. */
39 #include "dbxstclass.h"
44 /* Line number of beginning of current function, minus one.
45 Negative means not in a function or not using xcoff. */
47 static int xcoff_begin_function_line
= -1;
48 static int xcoff_inlining
= 0;
50 /* Name of the current include file. */
52 const char *xcoff_current_include_file
;
54 /* Name of the current function file. This is the file the `.bf' is
55 emitted from. In case a line is emitted from a different file,
56 (by including that file of course), then the line number will be
59 static const char *xcoff_current_function_file
;
61 /* Names of bss and data sections. These should be unique names for each
64 char *xcoff_bss_section_name
;
65 char *xcoff_private_data_section_name
;
66 char *xcoff_read_only_section_name
;
68 /* Last source file name mentioned in a NOTE insn. */
70 const char *xcoff_lastfile
;
72 /* Macro definitions used below. */
74 #define ABS_OR_RELATIVE_LINENO(LINENO) \
75 ((xcoff_inlining) ? (LINENO) : (LINENO) - xcoff_begin_function_line)
77 /* Output source line numbers via ".line" rather than ".stabd". */
78 #define ASM_OUTPUT_SOURCE_LINE(FILE,LINENUM) \
80 if (xcoff_begin_function_line >= 0) \
81 fprintf (FILE, "\t.line\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM)); \
84 #define ASM_OUTPUT_LFB(FILE,LINENUM) \
86 if (xcoff_begin_function_line == -1) \
88 xcoff_begin_function_line = (LINENUM) - 1;\
89 fprintf (FILE, "\t.bf\t%d\n", (LINENUM)); \
91 xcoff_current_function_file \
92 = (xcoff_current_include_file \
93 ? xcoff_current_include_file : main_input_filename); \
96 #define ASM_OUTPUT_LFE(FILE,LINENUM) \
98 fprintf (FILE, "\t.ef\t%d\n", (LINENUM)); \
99 xcoff_begin_function_line = -1; \
102 #define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
103 fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
105 #define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
106 fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
108 static void assign_type_number
PARAMS ((tree
, const char *, int));
109 static void xcoffout_block
PARAMS ((tree
, int, tree
));
110 static void xcoffout_source_file
PARAMS ((FILE *, const char *, int));
112 /* Support routines for XCOFF debugging info. */
114 /* Assign NUMBER as the stabx type number for the type described by NAME.
115 Search all decls in the list SYMS to find the type NAME. */
118 assign_type_number (syms
, name
, number
)
125 for (decl
= syms
; decl
; decl
= TREE_CHAIN (decl
))
127 && strcmp (IDENTIFIER_POINTER (DECL_NAME (decl
)), name
) == 0)
129 TREE_ASM_WRITTEN (decl
) = 1;
130 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = number
;
134 /* Setup gcc primitive types to use the XCOFF built-in type numbers where
138 xcoff_output_standard_types (syms
)
141 /* Handle built-in C types here. */
143 assign_type_number (syms
, "int", -1);
144 assign_type_number (syms
, "char", -2);
145 assign_type_number (syms
, "short int", -3);
146 assign_type_number (syms
, "long int", (TARGET_64BIT
? -31 : -4));
147 assign_type_number (syms
, "unsigned char", -5);
148 assign_type_number (syms
, "signed char", -6);
149 assign_type_number (syms
, "short unsigned int", -7);
150 assign_type_number (syms
, "unsigned int", -8);
151 /* No such type "unsigned". */
152 assign_type_number (syms
, "long unsigned int", (TARGET_64BIT
? -32 : -10));
153 assign_type_number (syms
, "void", -11);
154 assign_type_number (syms
, "float", -12);
155 assign_type_number (syms
, "double", -13);
156 assign_type_number (syms
, "long double", -14);
157 /* Pascal and Fortran types run from -15 to -29. */
158 assign_type_number (syms
, "wchar", -30);
159 assign_type_number (syms
, "long long int", -31);
160 assign_type_number (syms
, "long long unsigned int", -32);
161 /* Additional Fortran types run from -33 to -37. */
163 /* ??? Should also handle built-in C++ and Obj-C types. There perhaps
164 aren't any that C doesn't already have. */
167 /* Print an error message for unrecognized stab codes. */
169 #define UNKNOWN_STAB(STR) \
170 internal_error ("No sclass for %s stab (0x%x)\n", STR, stab)
172 /* Conversion routine from BSD stabs to AIX storage classes. */
175 stab_to_sclass (stab
)
184 UNKNOWN_STAB ("N_FNAME");
194 UNKNOWN_STAB ("N_MAIN");
200 UNKNOWN_STAB ("N_SSYM");
215 UNKNOWN_STAB ("N_SO");
218 UNKNOWN_STAB ("N_SOL");
221 UNKNOWN_STAB ("N_SLINE");
224 UNKNOWN_STAB ("N_DSLINE");
227 UNKNOWN_STAB ("N_BSLINE");
230 UNKNOWN_STAB ("N_BINCL");
233 UNKNOWN_STAB ("N_EINCL");
236 UNKNOWN_STAB ("N_EXCL");
239 UNKNOWN_STAB ("N_LBRAC");
242 UNKNOWN_STAB ("N_RBRAC");
252 UNKNOWN_STAB ("N_LENG");
255 UNKNOWN_STAB ("N_PC");
258 UNKNOWN_STAB ("N_M2C");
261 UNKNOWN_STAB ("N_SCOPE");
264 UNKNOWN_STAB ("N_CATCH");
267 UNKNOWN_STAB ("N_OPT");
274 /* Output debugging info to FILE to switch to sourcefile FILENAME.
275 INLINE_P is true if this is from an inlined function. */
278 xcoffout_source_file (file
, filename
, inline_p
)
280 const char *filename
;
284 && (xcoff_lastfile
== 0 || strcmp (filename
, xcoff_lastfile
)
285 || (inline_p
&& ! xcoff_inlining
)
286 || (! inline_p
&& xcoff_inlining
)))
288 if (xcoff_current_include_file
)
290 fprintf (file
, "\t.ei\t");
291 output_quoted_string (file
, xcoff_current_include_file
);
292 fprintf (file
, "\n");
293 xcoff_current_include_file
= NULL
;
295 xcoff_inlining
= inline_p
;
296 if (strcmp (main_input_filename
, filename
) || inline_p
)
298 fprintf (file
, "\t.bi\t");
299 output_quoted_string (file
, filename
);
300 fprintf (file
, "\n");
301 xcoff_current_include_file
= filename
;
303 xcoff_lastfile
= filename
;
307 /* Output a line number symbol entry for location (FILENAME, LINE). */
310 xcoffout_source_line (line
, filename
)
312 const char *filename
;
314 bool inline_p
= (strcmp (xcoff_current_function_file
, filename
) != 0
315 || (int) line
< xcoff_begin_function_line
);
317 xcoffout_source_file (asm_out_file
, filename
, inline_p
);
319 ASM_OUTPUT_SOURCE_LINE (asm_out_file
, line
);
322 /* Output the symbols defined in block number DO_BLOCK.
324 This function works by walking the tree structure of blocks,
325 counting blocks until it finds the desired block. */
327 static int do_block
= 0;
330 xcoffout_block (block
, depth
, args
)
337 /* Ignore blocks never expanded or otherwise marked as real. */
338 if (TREE_USED (block
))
340 /* When we reach the specified block, output its symbols. */
341 if (BLOCK_NUMBER (block
) == do_block
)
343 /* Output the syms of the block. */
344 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
345 dbxout_syms (BLOCK_VARS (block
));
347 dbxout_reg_parms (args
);
349 /* We are now done with the block. Don't go to inner blocks. */
352 /* If we are past the specified block, stop the scan. */
353 else if (BLOCK_NUMBER (block
) >= do_block
)
356 /* Output the subblocks. */
357 xcoffout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
359 block
= BLOCK_CHAIN (block
);
363 /* Describe the beginning of an internal block within a function.
364 Also output descriptions of variables defined in this block.
366 N is the number of the block, by order of beginning, counting from 1,
367 and not counting the outermost (function top-level) block.
368 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
369 if the count starts at 0 for the outermost one. */
372 xcoffout_begin_block (line
, n
)
376 tree decl
= current_function_decl
;
378 /* The IBM AIX compiler does not emit a .bb for the function level scope,
379 so we avoid it here also. */
381 ASM_OUTPUT_LBB (asm_out_file
, line
, n
);
384 xcoffout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
387 /* Describe the end line-number of an internal block within a function. */
390 xcoffout_end_block (line
, n
)
395 ASM_OUTPUT_LBE (asm_out_file
, line
, n
);
398 /* Called at beginning of function (before prologue).
399 Declare function as needed for debugging. */
402 xcoffout_declare_function (file
, decl
, name
)
412 for (i
= 0; name
[i
]; ++i
)
416 char *n
= (char *) alloca (i
+ 1);
417 strncpy (n
, name
, i
);
424 /* Any pending .bi or .ei must occur before the .function pseudo op.
425 Otherwise debuggers will think that the function is in the previous
426 file and/or at the wrong line number. */
427 xcoffout_source_file (file
, DECL_SOURCE_FILE (decl
), 0);
428 dbxout_symbol (decl
, 0);
430 /* .function NAME, TOP, MAPPING, TYPE, SIZE
431 16 and 044 are placeholders for backwards compatibility */
432 fprintf (file
, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
433 name
, name
, name
, name
);
436 /* Called at beginning of function body (at start of prologue).
437 Record the function's starting line number, so we can output
438 relative line numbers for the other lines.
439 Record the file name that this function is contained in. */
442 xcoffout_begin_prologue (line
, file
)
444 const char *file ATTRIBUTE_UNUSED
;
446 ASM_OUTPUT_LFB (asm_out_file
, line
);
447 dbxout_parms (DECL_ARGUMENTS (current_function_decl
));
449 /* Emit the symbols for the outermost BLOCK's variables. sdbout.c does this
450 in sdbout_begin_block, but there is no guarantee that there will be any
451 inner block 1, so we must do it here. This gives a result similar to
452 dbxout, so it does make some sense. */
453 do_block
= BLOCK_NUMBER (DECL_INITIAL (current_function_decl
));
454 xcoffout_block (DECL_INITIAL (current_function_decl
), 0,
455 DECL_ARGUMENTS (current_function_decl
));
457 ASM_OUTPUT_SOURCE_LINE (asm_out_file
, line
);
460 /* Called at end of function (before epilogue).
461 Describe end of outermost block. */
464 xcoffout_end_function (last_linenum
)
465 unsigned int last_linenum
;
467 ASM_OUTPUT_LFE (asm_out_file
, last_linenum
);
470 /* Output xcoff info for the absolute end of a function.
471 Called after the epilogue is output. */
474 xcoffout_end_epilogue ()
476 /* We need to pass the correct function size to .function, otherwise,
477 the xas assembler can't figure out the correct size for the function
478 aux entry. So, we emit a label after the last instruction which can
479 be used by the .function pseudo op to calculate the function size. */
481 const char *fname
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
484 fprintf (asm_out_file
, "FE..");
485 ASM_OUTPUT_LABEL (asm_out_file
, fname
);
487 #endif /* XCOFF_DEBUGGING_INFO */