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 GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
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 #if defined (USG) || !defined (HAVE_STAB_H)
50 /* Line number of beginning of current function, minus one.
51 Negative means not in a function or not using xcoff. */
53 static int xcoff_begin_function_line = -1;
54 static int xcoff_inlining = 0;
56 /* Name of the current include file. */
58 const char *xcoff_current_include_file;
60 /* Name of the current function file. This is the file the `.bf' is
61 emitted from. In case a line is emitted from a different file,
62 (by including that file of course), then the line number will be
65 static const char *xcoff_current_function_file;
67 /* Names of bss and data sections. These should be unique names for each
70 char *xcoff_bss_section_name;
71 char *xcoff_private_data_section_name;
72 char *xcoff_read_only_section_name;
74 /* Last source file name mentioned in a NOTE insn. */
76 const char *xcoff_lastfile;
78 /* Macro definitions used below. */
80 #define ABS_OR_RELATIVE_LINENO(LINENO) \
81 ((xcoff_inlining) ? (LINENO) : (LINENO) - xcoff_begin_function_line)
83 /* Output source line numbers via ".line" rather than ".stabd". */
84 #define ASM_OUTPUT_SOURCE_LINE(FILE,LINENUM) \
86 if (xcoff_begin_function_line >= 0) \
87 fprintf (FILE, "\t.line\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM)); \
90 #define ASM_OUTPUT_LFB(FILE,LINENUM) \
92 if (xcoff_begin_function_line == -1) \
94 xcoff_begin_function_line = (LINENUM) - 1;\
95 fprintf (FILE, "\t.bf\t%d\n", (LINENUM)); \
97 xcoff_current_function_file \
98 = (xcoff_current_include_file \
99 ? xcoff_current_include_file : main_input_filename); \
102 #define ASM_OUTPUT_LFE(FILE,LINENUM) \
104 fprintf (FILE, "\t.ef\t%d\n", (LINENUM)); \
105 xcoff_begin_function_line = -1; \
108 #define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
109 fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
111 #define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
112 fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
114 static void assign_type_number PARAMS ((tree, const char *, int));
115 static void xcoffout_block PARAMS ((tree, int, tree));
116 static void xcoffout_source_file PARAMS ((FILE *, const char *, int));
118 /* Support routines for XCOFF debugging info. */
120 /* Assign NUMBER as the stabx type number for the type described by NAME.
121 Search all decls in the list SYMS to find the type NAME. */
124 assign_type_number (syms, name, number)
131 for (decl = syms; decl; decl = TREE_CHAIN (decl))
133 && strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), name) == 0)
135 TREE_ASM_WRITTEN (decl) = 1;
136 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = number;
140 /* Setup gcc primitive types to use the XCOFF built-in type numbers where
144 xcoff_output_standard_types (syms)
147 /* Handle built-in C types here. */
149 assign_type_number (syms, "int", -1);
150 assign_type_number (syms, "char", -2);
151 assign_type_number (syms, "short int", -3);
152 assign_type_number (syms, "long int", (TARGET_64BIT ? -31 : -4));
153 assign_type_number (syms, "unsigned char", -5);
154 assign_type_number (syms, "signed char", -6);
155 assign_type_number (syms, "short unsigned int", -7);
156 assign_type_number (syms, "unsigned int", -8);
157 /* No such type "unsigned". */
158 assign_type_number (syms, "long unsigned int", (TARGET_64BIT ? -32 : -10));
159 assign_type_number (syms, "void", -11);
160 assign_type_number (syms, "float", -12);
161 assign_type_number (syms, "double", -13);
162 assign_type_number (syms, "long double", -14);
163 /* Pascal and Fortran types run from -15 to -29. */
164 assign_type_number (syms, "wchar", -30);
165 assign_type_number (syms, "long long int", -31);
166 assign_type_number (syms, "long long unsigned int", -32);
167 /* Additional Fortran types run from -33 to -37. */
169 /* ??? Should also handle built-in C++ and Obj-C types. There perhaps
170 aren't any that C doesn't already have. */
173 /* Print an error message for unrecognized stab codes. */
175 #define UNKNOWN_STAB(STR) \
176 internal_error ("No sclass for %s stab (0x%x)\n", STR, stab)
178 /* Conversion routine from BSD stabs to AIX storage classes. */
181 stab_to_sclass (stab)
190 UNKNOWN_STAB ("N_FNAME");
201 UNKNOWN_STAB ("N_MAIN");
208 UNKNOWN_STAB ("N_SSYM");
223 UNKNOWN_STAB ("N_SO");
226 UNKNOWN_STAB ("N_SOL");
229 UNKNOWN_STAB ("N_SLINE");
233 UNKNOWN_STAB ("N_DSLINE");
238 UNKNOWN_STAB ("N_BSLINE");
243 UNKNOWN_STAB ("N_BINCL");
248 UNKNOWN_STAB ("N_EINCL");
253 UNKNOWN_STAB ("N_EXCL");
257 UNKNOWN_STAB ("N_LBRAC");
260 UNKNOWN_STAB ("N_RBRAC");
270 UNKNOWN_STAB ("N_LENG");
273 UNKNOWN_STAB ("N_PC");
277 UNKNOWN_STAB ("N_M2C");
282 UNKNOWN_STAB ("N_SCOPE");
287 UNKNOWN_STAB ("N_CATCH");
292 UNKNOWN_STAB ("N_OPT");
300 /* Output debugging info to FILE to switch to sourcefile FILENAME.
301 INLINE_P is true if this is from an inlined function. */
304 xcoffout_source_file (file, filename, inline_p)
306 const char *filename;
310 && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
311 || (inline_p && ! xcoff_inlining)
312 || (! inline_p && xcoff_inlining)))
314 if (xcoff_current_include_file)
316 fprintf (file, "\t.ei\t");
317 output_quoted_string (file, xcoff_current_include_file);
318 fprintf (file, "\n");
319 xcoff_current_include_file = NULL;
321 xcoff_inlining = inline_p;
322 if (strcmp (main_input_filename, filename) || inline_p)
324 fprintf (file, "\t.bi\t");
325 output_quoted_string (file, filename);
326 fprintf (file, "\n");
327 xcoff_current_include_file = filename;
329 xcoff_lastfile = filename;
333 /* Output a line number symbol entry into output stream FILE,
334 for source file FILENAME and line number NOTE. */
337 xcoffout_source_line (file, filename, note)
339 const char *filename;
342 xcoffout_source_file (file, filename, RTX_INTEGRATED_P (note));
344 ASM_OUTPUT_SOURCE_LINE (file, NOTE_LINE_NUMBER (note));
347 /* Output the symbols defined in block number DO_BLOCK.
349 This function works by walking the tree structure of blocks,
350 counting blocks until it finds the desired block. */
352 static int do_block = 0;
355 xcoffout_block (block, depth, args)
362 /* Ignore blocks never expanded or otherwise marked as real. */
363 if (TREE_USED (block))
365 /* When we reach the specified block, output its symbols. */
366 if (BLOCK_NUMBER (block) == do_block)
368 /* Output the syms of the block. */
369 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
370 dbxout_syms (BLOCK_VARS (block));
372 dbxout_reg_parms (args);
374 /* We are now done with the block. Don't go to inner blocks. */
377 /* If we are past the specified block, stop the scan. */
378 else if (BLOCK_NUMBER (block) >= do_block)
381 /* Output the subblocks. */
382 xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
384 block = BLOCK_CHAIN (block);
388 /* Describe the beginning of an internal block within a function.
389 Also output descriptions of variables defined in this block.
391 N is the number of the block, by order of beginning, counting from 1,
392 and not counting the outermost (function top-level) block.
393 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
394 if the count starts at 0 for the outermost one. */
397 xcoffout_begin_block (file, line, n)
402 tree decl = current_function_decl;
404 /* The IBM AIX compiler does not emit a .bb for the function level scope,
405 so we avoid it here also. */
407 ASM_OUTPUT_LBB (file, line, n);
410 xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
413 /* Describe the end line-number of an internal block within a function. */
416 xcoffout_end_block (file, line, n)
422 ASM_OUTPUT_LBE (file, line, n);
425 /* Called at beginning of function (before prologue).
426 Declare function as needed for debugging. */
429 xcoffout_declare_function (file, decl, name)
439 for (i = 0; name[i]; ++i)
443 char *n = (char *) alloca (i + 1);
444 strncpy (n, name, i);
451 /* Any pending .bi or .ei must occur before the .function pseudo op.
452 Otherwise debuggers will think that the function is in the previous
453 file and/or at the wrong line number. */
454 xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
455 dbxout_symbol (decl, 0);
457 /* .function NAME, TOP, MAPPING, TYPE, SIZE
458 16 and 044 are placeholders for backwards compatibility */
459 fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
460 name, name, name, name);
463 /* Called at beginning of function body (after prologue).
464 Record the function's starting line number, so we can output
465 relative line numbers for the other lines.
466 Record the file name that this function is contained in. */
469 xcoffout_begin_function (file, last_linenum)
473 ASM_OUTPUT_LFB (file, last_linenum);
474 dbxout_parms (DECL_ARGUMENTS (current_function_decl));
476 /* Emit the symbols for the outermost BLOCK's variables. sdbout.c does this
477 in sdbout_begin_block, but there is no guarantee that there will be any
478 inner block 1, so we must do it here. This gives a result similar to
479 dbxout, so it does make some sense. */
480 do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
481 xcoffout_block (DECL_INITIAL (current_function_decl), 0,
482 DECL_ARGUMENTS (current_function_decl));
484 ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
487 /* Called at end of function (before epilogue).
488 Describe end of outermost block. */
491 xcoffout_end_function (file, last_linenum)
495 ASM_OUTPUT_LFE (file, last_linenum);
498 /* Output xcoff info for the absolute end of a function.
499 Called after the epilogue is output. */
502 xcoffout_end_epilogue (file)
505 /* We need to pass the correct function size to .function, otherwise,
506 the xas assembler can't figure out the correct size for the function
507 aux entry. So, we emit a label after the last instruction which can
508 be used by the .function pseudo op to calculate the function size. */
510 const char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
513 fprintf (file, "FE..");
514 ASM_OUTPUT_LABEL (file, fname);
516 #endif /* XCOFF_DEBUGGING_INFO */