/* Output xcoff-format symbol table information from GNU compiler.
- Copyright (C) 1992 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1994, 1995, 1997, 1998,
+ 1999, 2000 Free Software Foundation, Inc.
This file is part of GNU CC.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
/* Output xcoff-format symbol table data. The main functionality is contained
interface. Many functions are very similar to their counterparts in
sdbout.c. */
-/* Include this first, because it may define MIN and MAX. */
-#include <stdio.h>
-
#include "config.h"
+#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "flags.h"
+#include "toplev.h"
+#include "output.h"
+#include "ggc.h"
#ifdef XCOFF_DEBUGGING_INFO
/* This defines the C_* storage classes. */
#include <dbxstclass.h>
-#include "xcoff.h"
+#include "xcoffout.h"
+#include "dbxout.h"
-#if defined (USG) || defined (NO_STAB_H)
+#if defined (USG) || !defined (HAVE_STAB_H)
#include "gstab.h"
#else
#include <stab.h>
#endif
#endif
-/* These are GNU extensions we need to reference in this file. */
-#ifndef N_DSLINE
-#define N_DSLINE 0x46
-#endif
-#ifndef N_BSLINE
-#define N_BSLINE 0x48
-#endif
-
/* Line number of beginning of current function, minus one.
Negative means not in a function or not using xcoff. */
-int xcoff_begin_function_line = -1;
+static int xcoff_begin_function_line = -1;
+static int xcoff_inlining = 0;
/* Name of the current include file. */
(by including that file of course), then the line number will be
absolute. */
-char *xcoff_current_function_file;
+static char *xcoff_current_function_file;
/* Names of bss and data sections. These should be unique names for each
compilation unit. */
char *xcoff_bss_section_name;
char *xcoff_private_data_section_name;
char *xcoff_read_only_section_name;
+
+/* Last source file name mentioned in a NOTE insn. */
+
+char *xcoff_lastfile;
\f
/* Macro definitions used below. */
-/* Ensure we don't output a negative line number. */
-#define MAKE_LINE_SAFE(LINE) \
- if (LINE <= xcoff_begin_function_line) \
- LINE = xcoff_begin_function_line + 1 \
+
+#define ABS_OR_RELATIVE_LINENO(LINENO) \
+((xcoff_inlining) ? (LINENO) : (LINENO) - xcoff_begin_function_line)
+
+/* Output source line numbers via ".line" rather than ".stabd". */
+#define ASM_OUTPUT_SOURCE_LINE(FILE,LINENUM) \
+ do { \
+ if (xcoff_begin_function_line >= 0) \
+ fprintf (FILE, "\t.line\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM)); \
+ } while (0)
#define ASM_OUTPUT_LFB(FILE,LINENUM) \
{ \
#define ASM_OUTPUT_LFE(FILE,LINENUM) \
do { \
- int linenum = LINENUM; \
- MAKE_LINE_SAFE (linenum); \
- fprintf (FILE, "\t.ef\t%d\n", ABS_OR_RELATIVE_LINENO (linenum)); \
+ fprintf (FILE, "\t.ef\t%d\n", (LINENUM)); \
xcoff_begin_function_line = -1; \
} while (0)
#define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
- do { \
- int linenum = LINENUM; \
- MAKE_LINE_SAFE (linenum); \
- fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (linenum)); \
- } while (0)
+ fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
#define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
- do { \
- int linenum = LINENUM; \
- MAKE_LINE_SAFE (linenum); \
- fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (linenum)); \
- } while (0)
+ fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
+
+static void assign_type_number PARAMS ((tree, char *, int));
+static void xcoffout_block PARAMS ((tree, int, tree));
\f
/* Support routines for XCOFF debugging info. */
tree decl;
for (decl = syms; decl; decl = TREE_CHAIN (decl))
- if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), name))
+ if (DECL_NAME (decl)
+ && strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), name) == 0)
{
TREE_ASM_WRITTEN (decl) = 1;
TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = number;
assign_type_number (syms, "int", -1);
assign_type_number (syms, "char", -2);
assign_type_number (syms, "short int", -3);
- assign_type_number (syms, "long int", -4);
+ assign_type_number (syms, "long int", (TARGET_64BIT ? -31 : -4));
assign_type_number (syms, "unsigned char", -5);
assign_type_number (syms, "signed char", -6);
assign_type_number (syms, "short unsigned int", -7);
assign_type_number (syms, "unsigned int", -8);
/* No such type "unsigned". */
- assign_type_number (syms, "long unsigned int", -10);
+ assign_type_number (syms, "long unsigned int", (TARGET_64BIT ? -32 : -10));
assign_type_number (syms, "void", -11);
assign_type_number (syms, "float", -12);
assign_type_number (syms, "double", -13);
assign_type_number (syms, "long double", -14);
/* Pascal and Fortran types run from -15 to -29. */
- /* No such type "wchar". */
-
- /* "long long int", and "long long unsigned int", are not handled here,
- because there are no predefined types that match them. */
+ assign_type_number (syms, "wchar", -30);
+ assign_type_number (syms, "long long int", -31);
+ assign_type_number (syms, "long long unsigned int", -32);
+ /* Additional Fortran types run from -33 to -37. */
/* ??? Should also handle built-in C++ and Obj-C types. There perhaps
aren't any that C doesn't already have. */
#define UNKNOWN_STAB(STR) \
do { \
- fprintf(stderr, "Error, unknown stab %s: : 0x%x\n", STR, stab); \
+ error ("Unknown stab %s: : 0x%x\n", STR, stab); \
fflush (stderr); \
} while (0)
case N_LCSYM:
return C_STSYM;
+#ifdef N_MAIN
case N_MAIN:
UNKNOWN_STAB ("N_MAIN");
abort ();
+#endif
case N_RSYM:
return C_RSYM;
UNKNOWN_STAB ("N_SLINE");
abort ();
+#ifdef N_DSLINE
case N_DSLINE:
UNKNOWN_STAB ("N_DSLINE");
abort ();
+#endif
+#ifdef N_BSLINE
case N_BSLINE:
UNKNOWN_STAB ("N_BSLINE");
abort ();
+#endif
#if 0
/* This has the same value as N_BSLINE. */
case N_BROWS:
abort ();
#endif
+#ifdef N_BINCL
case N_BINCL:
UNKNOWN_STAB ("N_BINCL");
abort ();
+#endif
+#ifdef N_EINCL
case N_EINCL:
UNKNOWN_STAB ("N_EINCL");
abort ();
+#endif
+#ifdef N_EXCL
case N_EXCL:
UNKNOWN_STAB ("N_EXCL");
abort ();
+#endif
case N_LBRAC:
UNKNOWN_STAB ("N_LBRAC");
UNKNOWN_STAB ("N_PC");
abort ();
+#ifdef N_M2C
case N_M2C:
UNKNOWN_STAB ("N_M2C");
abort ();
+#endif
+#ifdef N_SCOPE
case N_SCOPE:
UNKNOWN_STAB ("N_SCOPE");
abort ();
+#endif
case N_CATCH:
UNKNOWN_STAB ("N_CATCH");
abort ();
}
}
-
-/* In XCOFF, we have to have this .bf before the function prologue.
- Rely on the value of `dbx_begin_function_line' not to duplicate .bf. */
+\f
+/* Output debugging info to FILE to switch to sourcefile FILENAME.
+ INLINE_P is true if this is from an inlined function. */
void
-xcoffout_output_first_source_line (file, last_linenum)
+xcoffout_source_file (file, filename, inline_p)
FILE *file;
- int last_linenum;
+ char *filename;
+ int inline_p;
{
- ASM_OUTPUT_LFB (file, last_linenum);
- dbxout_parms (DECL_ARGUMENTS (current_function_decl));
- ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
+ if (filename
+ && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
+ || (inline_p && ! xcoff_inlining)
+ || (! inline_p && xcoff_inlining)))
+ {
+ if (xcoff_current_include_file)
+ {
+ fprintf (file, "\t.ei\t");
+ output_quoted_string (file, xcoff_current_include_file);
+ fprintf (file, "\n");
+ xcoff_current_include_file = NULL;
+ }
+ xcoff_inlining=inline_p;
+ if (strcmp (main_input_filename, filename) || inline_p)
+ {
+ fprintf (file, "\t.bi\t");
+ output_quoted_string (file, filename);
+ fprintf (file, "\n");
+ xcoff_current_include_file = filename;
+ }
+
+ if (!xcoff_lastfile)
+ ggc_add_string_root (&xcoff_lastfile, 1);
+
+ xcoff_lastfile = filename;
+ }
}
+/* Output a line number symbol entry into output stream FILE,
+ for source file FILENAME and line number NOTE. */
+
+void
+xcoffout_source_line (file, filename, note)
+ FILE *file;
+ char *filename;
+ rtx note;
+{
+ xcoffout_source_file (file, filename, RTX_INTEGRATED_P (note));
+
+ ASM_OUTPUT_SOURCE_LINE (file, NOTE_LINE_NUMBER (note));
+}
+\f
/* Output the symbols defined in block number DO_BLOCK.
- Set NEXT_BLOCK_NUMBER to 0 before calling.
This function works by walking the tree structure of blocks,
counting blocks until it finds the desired block. */
static int do_block = 0;
-static int next_block_number;
-
static void
xcoffout_block (block, depth, args)
register tree block;
if (TREE_USED (block))
{
/* When we reach the specified block, output its symbols. */
- if (next_block_number == do_block)
+ if (BLOCK_NUMBER (block) == do_block)
{
/* Output the syms of the block. */
if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
return;
}
/* If we are past the specified block, stop the scan. */
- else if (next_block_number >= do_block)
+ else if (BLOCK_NUMBER (block) >= do_block)
return;
- next_block_number++;
-
/* Output the subblocks. */
- xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, 0);
+ xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
}
block = BLOCK_CHAIN (block);
}
{
tree decl = current_function_decl;
- ASM_OUTPUT_LBB (file, line, n);
+
+ /* The IBM AIX compiler does not emit a .bb for the function level scope,
+ so we avoid it here also. */
+ if (n != 1)
+ ASM_OUTPUT_LBB (file, line, n);
do_block = n;
- next_block_number = 0;
xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
}
int line;
int n;
{
- ASM_OUTPUT_LBE (file, line, n);
+ if (n != 1)
+ ASM_OUTPUT_LBE (file, line, n);
+}
+
+/* Called at beginning of function (before prologue).
+ Declare function as needed for debugging. */
+
+void
+xcoffout_declare_function (file, decl, name)
+ FILE *file;
+ tree decl;
+ char *name;
+{
+ char *n = name;
+ int i;
+
+ if (*n == '*')
+ n++;
+ else
+ for (i = 0; name[i]; ++i)
+ {
+ if (name[i] == '[')
+ {
+ n = (char *) alloca (i + 1);
+ strncpy (n, name, i);
+ n[i] = '\0';
+ break;
+ }
+ }
+
+ /* Any pending .bi or .ei must occur before the .function pseudo op.
+ Otherwise debuggers will think that the function is in the previous
+ file and/or at the wrong line number. */
+ xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
+ dbxout_symbol (decl, 0);
+
+ /* .function NAME, TOP, MAPPING, TYPE, SIZE
+ 16 and 044 are placeholders for backwards compatibility */
+ fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n", n, n, n, n);
}
/* Called at beginning of function body (after prologue).
int last_linenum;
{
ASM_OUTPUT_LFB (file, last_linenum);
+ dbxout_parms (DECL_ARGUMENTS (current_function_decl));
+
+ /* Emit the symbols for the outermost BLOCK's variables. sdbout.c does this
+ in sdbout_begin_block, but there is no guarantee that there will be any
+ inner block 1, so we must do it here. This gives a result similar to
+ dbxout, so it does make some sense. */
+ do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
+ xcoffout_block (DECL_INITIAL (current_function_decl), 0,
+ DECL_ARGUMENTS (current_function_decl));
+
+ ASM_OUTPUT_SOURCE_LINE (file, last_linenum);
}
/* Called at end of function (before epilogue).
/* We need to pass the correct function size to .function, otherwise,
the xas assembler can't figure out the correct size for the function
aux entry. So, we emit a label after the last instruction which can
- be used by the .function psuedo op to calculate the function size. */
+ be used by the .function pseudo op to calculate the function size. */
char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
if (*fname == '*')
++fname;
- fprintf (file, "L..end_");
+ fprintf (file, "FE..");
ASM_OUTPUT_LABEL (file, fname);
}
#endif /* XCOFF_DEBUGGING_INFO */