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