1 /* Output xcoff-format symbol table information from GNU compiler.
2 Copyright (C) 1992-2019 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along 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
48 static int xcoff_begin_function_line = -1;
49 static int xcoff_inlining = 0;
50
51 /* Name of the current include file. */
52
53 const 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
60 static 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
65 char *xcoff_bss_section_name;
66 char *xcoff_private_data_section_name;
67 char *xcoff_private_rodata_section_name;
68 char *xcoff_tls_data_section_name;
69 char *xcoff_tbss_section_name;
70 char *xcoff_read_only_section_name;
71
72 /* Last source file name mentioned in a NOTE insn. */
73
74 const 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
123 static void xcoffout_block (tree, int, tree);
124 static void xcoffout_source_file (FILE *, const char *, int);
125
126 /* Support routines for XCOFF debugging info. */
127
128 struct xcoff_type_number
129 {
130 const char *name;
131 int number;
132 };
133 static 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. */
160 int
xcoff_assign_fundamental_type_number(tree decl)161 xcoff_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
199 int
stab_to_sclass(int stab)200 stab_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
301 static void
xcoffout_source_file(FILE * file,const char * filename,int inline_p)302 xcoffout_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
331 void
xcoffout_source_line(unsigned int line,unsigned int column ATTRIBUTE_UNUSED,const char * filename,int discriminator ATTRIBUTE_UNUSED,bool is_stmt ATTRIBUTE_UNUSED)332 xcoffout_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
349 static unsigned int do_block = 0;
350
351 static void
xcoffout_block(tree block,int depth,tree args)352 xcoffout_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
390 void
xcoffout_begin_block(unsigned int line,unsigned int n)391 xcoffout_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
406 void
xcoffout_end_block(unsigned int line,unsigned int n)407 xcoffout_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
416 void
xcoffout_declare_function(FILE * file,tree decl,const char * name)417 xcoffout_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
449 void
xcoffout_begin_prologue(unsigned int line,unsigned int column ATTRIBUTE_UNUSED,const char * file ATTRIBUTE_UNUSED)450 xcoffout_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
471 void
xcoffout_end_function(unsigned int last_linenum)472 xcoffout_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
480 void
xcoffout_end_epilogue(unsigned int line ATTRIBUTE_UNUSED,const char * file ATTRIBUTE_UNUSED)481 xcoffout_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