[gcc.git] / gcc / xcoffout.c

/* Output xcoff-format symbol table information from GNU compiler.
   Copyright (C) 1992, 1994, 1995, 1997, 1998 Free Software Foundation, Inc.

This file is part of GNU CC.

GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

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, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */


/* Output xcoff-format symbol table data.  The main functionality is contained
   in dbxout.c.  This file implements the sdbout-like parts of the xcoff
   interface.  Many functions are very similar to their counterparts in
   sdbout.c.  */

#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 "xcoffout.h"
#include "dbxout.h"

#if defined (USG) || !defined (HAVE_STAB_H)
#include "gstab.h"
#else
#include <stab.h>

/* This is a GNU extension we need to reference in this file.  */
#ifndef N_CATCH
#define N_CATCH 0x54
#endif
#endif

/* Line number of beginning of current function, minus one.
   Negative means not in a function or not using xcoff.  */

static int xcoff_begin_function_line = -1;
static int xcoff_inlining = 0;

/* Name of the current include file.  */

char *xcoff_current_include_file;

/* Name of the current function file.  This is the file the `.bf' is
   emitted from.  In case a line is emitted from a different file,
   (by including that file of course), then the line number will be
   absolute.  */

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.  */

#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) \
{						\
  if (xcoff_begin_function_line == -1)		\
    {						\
      xcoff_begin_function_line = (LINENUM) - 1;\
      fprintf (FILE, "\t.bf\t%d\n", (LINENUM));	\
    }						\
  xcoff_current_function_file			\
    = (xcoff_current_include_file		\
       ? xcoff_current_include_file : main_input_filename); \
}

#define ASM_OUTPUT_LFE(FILE,LINENUM) \
  do {						\
    fprintf (FILE, "\t.ef\t%d\n", (LINENUM));	\
    xcoff_begin_function_line = -1;		\
  } while (0)

#define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
  fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))

#define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
  fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))

static void assign_type_number		PROTO((tree, char *, int));
static void xcoffout_block		PROTO((tree, int, tree));
\f
/* Support routines for XCOFF debugging info.  */

/* Assign NUMBER as the stabx type number for the type described by NAME.
   Search all decls in the list SYMS to find the type NAME.  */

static void
assign_type_number (syms, name, number)
     tree syms;
     char *name;
     int number;
{
  tree decl;

  for (decl = syms; decl; decl = TREE_CHAIN (decl))
    if (DECL_NAME (decl)
	&& strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), name) == 0)
      {
	TREE_ASM_WRITTEN (decl) = 1;
	TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = number;
      }
}

/* Setup gcc primitive types to use the XCOFF built-in type numbers where
   possible.  */

void
xcoff_output_standard_types (syms)
     tree syms;
{
  /* Handle built-in C types here.  */

  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", (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", (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.  */
  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.  */
}

/* Print an error message for unrecognized stab codes.  */

#define UNKNOWN_STAB(STR)	\
   do { \
     error ("Unknown stab %s: : 0x%x\n", STR, stab);	\
     fflush (stderr);	\
   } while (0)

/* Conversion routine from BSD stabs to AIX storage classes.  */

int
stab_to_sclass (stab)
     int stab;
{
  switch (stab)
    {
    case N_GSYM:
      return C_GSYM;

    case N_FNAME:
      UNKNOWN_STAB ("N_FNAME"); 
      abort();

    case N_FUN:
      return C_FUN;

    case N_STSYM:
    case N_LCSYM:
      return C_STSYM;

#ifdef N_MAIN
    case N_MAIN:
      UNKNOWN_STAB ("N_MAIN"); 
      abort ();
#endif

    case N_RSYM:
      return C_RSYM;

    case N_SSYM:
      UNKNOWN_STAB ("N_SSYM"); 
      abort ();

    case N_RPSYM:
      return C_RPSYM;

    case N_PSYM:
      return C_PSYM;
    case N_LSYM:
      return C_LSYM;
    case N_DECL:
      return C_DECL;
    case N_ENTRY:
      return C_ENTRY;

    case N_SO:
      UNKNOWN_STAB ("N_SO"); 
      abort ();

    case N_SOL:
      UNKNOWN_STAB ("N_SOL"); 
      abort ();

    case N_SLINE:
      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:
      UNKNOWN_STAB ("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"); 
      abort ();

    case N_RBRAC:
      UNKNOWN_STAB ("N_RBRAC"); 
      abort ();

    case N_BCOMM:
      return C_BCOMM;
    case N_ECOMM:
      return C_ECOMM;
    case N_ECOML:
      return C_ECOML;

    case N_LENG:
      UNKNOWN_STAB ("N_LENG"); 
      abort ();

    case N_PC:
      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 ();

    default:
      UNKNOWN_STAB ("default"); 
      abort ();
  }
}
\f
/* Output debugging info to FILE to switch to sourcefile FILENAME.
   INLINE_P is true if this is from an inlined function.  */

void
xcoffout_source_file (file, filename, inline_p)
     FILE *file;
     char *filename;
     int inline_p;
{
  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;
     int depth;
     tree args;
{
  while (block)
    {
      /* Ignore blocks never expanded or otherwise marked as real.  */
      if (TREE_USED (block))
	{
	  /* When we reach the specified block, output its symbols.  */
	  if (next_block_number == do_block)
	    {
	      /* Output the syms of the block.  */
	      if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
		dbxout_syms (BLOCK_VARS (block));
	      if (args)
		dbxout_reg_parms (args);

	      /* We are now done with the block.  Don't go to inner blocks.  */
	      return;
	    }
	  /* If we are past the specified block, stop the scan.  */
	  else if (next_block_number >= do_block)
	    return;

	  next_block_number++;

	  /* Output the subblocks.  */
	  xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
	}
      block = BLOCK_CHAIN (block);
    }
}

/* Describe the beginning of an internal block within a function.
   Also output descriptions of variables defined in this block.

   N is the number of the block, by order of beginning, counting from 1,
   and not counting the outermost (function top-level) block.
   The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
   if the count starts at 0 for the outermost one.  */

void
xcoffout_begin_block (file, line, n)
     FILE *file;
     int line;
     int n;
{
  tree decl = current_function_decl;

  
  /* 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));
}

/* Describe the end line-number of an internal block within a function.  */

void
xcoffout_end_block (file, line, n)
     FILE *file;
     int line;
     int 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).
   Record the function's starting line number, so we can output
   relative line numbers for the other lines.
   Record the file name that this function is contained in.  */

void
xcoffout_begin_function (file, last_linenum)
     FILE *file;
     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 = 0;
  next_block_number = 0;
  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).
   Describe end of outermost block.  */

void
xcoffout_end_function (file, last_linenum)
     FILE *file;
     int last_linenum;
{
  ASM_OUTPUT_LFE (file, last_linenum);
}

/* Output xcoff info for the absolute end of a function.
   Called after the epilogue is output.  */

void
xcoffout_end_epilogue (file)
     FILE *file;
{
  /* 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 pseudo op to calculate the function size.  */

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