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