Merge branch 'master' of ssh://crater.dragonflybsd.org/repository/git/dragonfly
[dragonfly.git] / contrib / gcc-3.4 / gcc / xcoffout.c
CommitLineData
003757ed
MD
1/* Output xcoff-format symbol table information from GNU compiler.
2 Copyright (C) 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003
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, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, 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\f
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" rather than ".stabd". */
81#define ASM_OUTPUT_SOURCE_LINE(FILE,LINENUM,COUNTER) \
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 assign_type_number (tree, const char *, int);
116static void xcoffout_block (tree, int, tree);
117static void xcoffout_source_file (FILE *, const char *, int);
118\f
119/* Support routines for XCOFF debugging info. */
120
121/* Assign NUMBER as the stabx type number for the type described by NAME.
122 Search all decls in the list SYMS to find the type NAME. */
123
124static void
125assign_type_number (tree syms, const char *name, int number)
126{
127 tree decl;
128
129 for (decl = syms; decl; decl = TREE_CHAIN (decl))
130 if (DECL_NAME (decl)
131 && strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), name) == 0)
132 {
133 TREE_ASM_WRITTEN (decl) = 1;
134 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = number;
135 }
136}
137
138/* Setup gcc primitive types to use the XCOFF built-in type numbers where
139 possible. */
140
141void
142xcoff_output_standard_types (tree syms)
143{
144 /* Handle built-in C types here. */
145
146 assign_type_number (syms, "int", -1);
147 assign_type_number (syms, "char", -2);
148 assign_type_number (syms, "short int", -3);
149 assign_type_number (syms, "long int", (TARGET_64BIT ? -31 : -4));
150 assign_type_number (syms, "unsigned char", -5);
151 assign_type_number (syms, "signed char", -6);
152 assign_type_number (syms, "short unsigned int", -7);
153 assign_type_number (syms, "unsigned int", -8);
154 /* No such type "unsigned". */
155 assign_type_number (syms, "long unsigned int", (TARGET_64BIT ? -32 : -10));
156 assign_type_number (syms, "void", -11);
157 assign_type_number (syms, "float", -12);
158 assign_type_number (syms, "double", -13);
159 assign_type_number (syms, "long double", -14);
160 /* Pascal and Fortran types run from -15 to -29. */
161 assign_type_number (syms, "wchar", -30);
162 assign_type_number (syms, "long long int", -31);
163 assign_type_number (syms, "long long unsigned int", -32);
164 /* Additional Fortran types run from -33 to -37. */
165
166 /* ??? Should also handle built-in C++ and Obj-C types. There perhaps
167 aren't any that C doesn't already have. */
168}
169
170/* Print an error message for unrecognized stab codes. */
171
172#define UNKNOWN_STAB(STR) \
173 internal_error ("no sclass for %s stab (0x%x)\n", STR, stab)
174
175/* Conversion routine from BSD stabs to AIX storage classes. */
176
177int
178stab_to_sclass (int stab)
179{
180 switch (stab)
181 {
182 case N_GSYM:
183 return C_GSYM;
184
185 case N_FNAME:
186 UNKNOWN_STAB ("N_FNAME");
187
188 case N_FUN:
189 return C_FUN;
190
191 case N_STSYM:
192 case N_LCSYM:
193 return C_STSYM;
194
195 case N_MAIN:
196 UNKNOWN_STAB ("N_MAIN");
197
198 case N_RSYM:
199 return C_RSYM;
200
201 case N_SSYM:
202 UNKNOWN_STAB ("N_SSYM");
203
204 case N_RPSYM:
205 return C_RPSYM;
206
207 case N_PSYM:
208 return C_PSYM;
209 case N_LSYM:
210 return C_LSYM;
211 case N_DECL:
212 return C_DECL;
213 case N_ENTRY:
214 return C_ENTRY;
215
216 case N_SO:
217 UNKNOWN_STAB ("N_SO");
218
219 case N_SOL:
220 UNKNOWN_STAB ("N_SOL");
221
222 case N_SLINE:
223 UNKNOWN_STAB ("N_SLINE");
224
225 case N_DSLINE:
226 UNKNOWN_STAB ("N_DSLINE");
227
228 case N_BSLINE:
229 UNKNOWN_STAB ("N_BSLINE");
230
231 case N_BINCL:
232 UNKNOWN_STAB ("N_BINCL");
233
234 case N_EINCL:
235 UNKNOWN_STAB ("N_EINCL");
236
237 case N_EXCL:
238 UNKNOWN_STAB ("N_EXCL");
239
240 case N_LBRAC:
241 UNKNOWN_STAB ("N_LBRAC");
242
243 case N_RBRAC:
244 UNKNOWN_STAB ("N_RBRAC");
245
246 case N_BCOMM:
247 return C_BCOMM;
248 case N_ECOMM:
249 return C_ECOMM;
250 case N_ECOML:
251 return C_ECOML;
252
253 case N_LENG:
254 UNKNOWN_STAB ("N_LENG");
255
256 case N_PC:
257 UNKNOWN_STAB ("N_PC");
258
259 case N_M2C:
260 UNKNOWN_STAB ("N_M2C");
261
262 case N_SCOPE:
263 UNKNOWN_STAB ("N_SCOPE");
264
265 case N_CATCH:
266 UNKNOWN_STAB ("N_CATCH");
267
268 case N_OPT:
269 UNKNOWN_STAB ("N_OPT");
270
271 default:
272 UNKNOWN_STAB ("?");
273 }
274}
275\f
276/* Output debugging info to FILE to switch to sourcefile FILENAME.
277 INLINE_P is true if this is from an inlined function. */
278
279static void
280xcoffout_source_file (FILE *file, const char *filename, int inline_p)
281{
282 if (filename
283 && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
284 || (inline_p && ! xcoff_inlining)
285 || (! inline_p && xcoff_inlining)))
286 {
287 if (xcoff_current_include_file)
288 {
289 fprintf (file, "\t.ei\t");
290 output_quoted_string (file, xcoff_current_include_file);
291 fprintf (file, "\n");
292 xcoff_current_include_file = NULL;
293 }
294 xcoff_inlining = inline_p;
295 if (strcmp (main_input_filename, filename) || inline_p)
296 {
297 fprintf (file, "\t.bi\t");
298 output_quoted_string (file, filename);
299 fprintf (file, "\n");
300 xcoff_current_include_file = filename;
301 }
302 xcoff_lastfile = filename;
303 }
304}
305
306/* Output a line number symbol entry for location (FILENAME, LINE). */
307
308void
309xcoffout_source_line (unsigned int line, const char *filename)
310{
311 bool inline_p = (strcmp (xcoff_current_function_file, filename) != 0
312 || (int) line < xcoff_begin_function_line);
313
314 xcoffout_source_file (asm_out_file, filename, inline_p);
315
316 ASM_OUTPUT_SOURCE_LINE (asm_out_file, line, 0);
317}
318\f
319/* Output the symbols defined in block number DO_BLOCK.
320
321 This function works by walking the tree structure of blocks,
322 counting blocks until it finds the desired block. */
323
324static int do_block = 0;
325
326static void
327xcoffout_block (tree block, int depth, tree args)
328{
329 while (block)
330 {
331 /* Ignore blocks never expanded or otherwise marked as real. */
332 if (TREE_USED (block))
333 {
334 /* When we reach the specified block, output its symbols. */
335 if (BLOCK_NUMBER (block) == do_block)
336 {
337 /* Output the syms of the block. */
338 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
339 dbxout_syms (BLOCK_VARS (block));
340 if (args)
341 dbxout_reg_parms (args);
342
343 /* We are now done with the block. Don't go to inner blocks. */
344 return;
345 }
346 /* If we are past the specified block, stop the scan. */
347 else if (BLOCK_NUMBER (block) >= do_block)
348 return;
349
350 /* Output the subblocks. */
351 xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
352 }
353 block = BLOCK_CHAIN (block);
354 }
355}
356
357/* Describe the beginning of an internal block within a function.
358 Also output descriptions of variables defined in this block.
359
360 N is the number of the block, by order of beginning, counting from 1,
361 and not counting the outermost (function top-level) block.
362 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
363 if the count starts at 0 for the outermost one. */
364
365void
366xcoffout_begin_block (unsigned int line, unsigned int n)
367{
368 tree decl = current_function_decl;
369
370 /* The IBM AIX compiler does not emit a .bb for the function level scope,
371 so we avoid it here also. */
372 if (n != 1)
373 ASM_OUTPUT_LBB (asm_out_file, line, n);
374
375 do_block = n;
376 xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
377}
378
379/* Describe the end line-number of an internal block within a function. */
380
381void
382xcoffout_end_block (unsigned int line, unsigned int n)
383{
384 if (n != 1)
385 ASM_OUTPUT_LBE (asm_out_file, line, n);
386}
387
388/* Called at beginning of function (before prologue).
389 Declare function as needed for debugging. */
390
391void
392xcoffout_declare_function (FILE *file, tree decl, const char *name)
393{
394 int i;
395
396 if (*name == '*')
397 name++;
398 else
399 for (i = 0; name[i]; ++i)
400 {
401 if (name[i] == '[')
402 {
403 char *n = alloca (i + 1);
404 strncpy (n, name, i);
405 n[i] = '\0';
406 name = n;
407 break;
408 }
409 }
410
411 /* Any pending .bi or .ei must occur before the .function pseudo op.
412 Otherwise debuggers will think that the function is in the previous
413 file and/or at the wrong line number. */
414 xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
415 dbxout_symbol (decl, 0);
416
417 /* .function NAME, TOP, MAPPING, TYPE, SIZE
418 16 and 044 are placeholders for backwards compatibility */
419 fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
420 name, name, name, name);
421}
422
423/* Called at beginning of function body (at start of prologue).
424 Record the function's starting line number, so we can output
425 relative line numbers for the other lines.
426 Record the file name that this function is contained in. */
427
428void
429xcoffout_begin_prologue (unsigned int line,
430 const char *file ATTRIBUTE_UNUSED)
431{
432 ASM_OUTPUT_LFB (asm_out_file, line);
433 dbxout_parms (DECL_ARGUMENTS (current_function_decl));
434
435 /* Emit the symbols for the outermost BLOCK's variables. sdbout.c does this
436 in sdbout_begin_block, but there is no guarantee that there will be any
437 inner block 1, so we must do it here. This gives a result similar to
438 dbxout, so it does make some sense. */
439 do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
440 xcoffout_block (DECL_INITIAL (current_function_decl), 0,
441 DECL_ARGUMENTS (current_function_decl));
442
443 ASM_OUTPUT_SOURCE_LINE (asm_out_file, line, 0);
444}
445
446/* Called at end of function (before epilogue).
447 Describe end of outermost block. */
448
449void
450xcoffout_end_function (unsigned int last_linenum)
451{
452 ASM_OUTPUT_LFE (asm_out_file, last_linenum);
453}
454
455/* Output xcoff info for the absolute end of a function.
456 Called after the epilogue is output. */
457
458void
459xcoffout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
460 const char *file ATTRIBUTE_UNUSED)
461{
462 /* We need to pass the correct function size to .function, otherwise,
463 the xas assembler can't figure out the correct size for the function
464 aux entry. So, we emit a label after the last instruction which can
465 be used by the .function pseudo op to calculate the function size. */
466
467 const char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
468 if (*fname == '*')
469 ++fname;
470 fprintf (asm_out_file, "FE..");
471 ASM_OUTPUT_LABEL (asm_out_file, fname);
472}
473#endif /* XCOFF_DEBUGGING_INFO */