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