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