* charset.c (convert_using_iconv): Close out any shift states,
[official-gcc.git] / gcc / xcoffout.c
blobfb99903b76d5f6a64f86d033b85638c8d1d6091f
1 /* Output xcoff-format symbol table information from GNU compiler.
2 Copyright (C) 1992, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 2004,
3 2007 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 /* Output xcoff-format symbol table data. The main functionality is contained
22 in dbxout.c. This file implements the sdbout-like parts of the xcoff
23 interface. Many functions are very similar to their counterparts in
24 sdbout.c. */
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "tree.h"
31 #include "rtl.h"
32 #include "flags.h"
33 #include "toplev.h"
34 #include "output.h"
35 #include "ggc.h"
36 #include "target.h"
37 #include "debug.h"
39 #ifdef XCOFF_DEBUGGING_INFO
41 /* This defines the C_* storage classes. */
42 #include "xcoff.h"
43 #include "xcoffout.h"
44 #include "dbxout.h"
45 #include "gstab.h"
47 /* Line number of beginning of current function, minus one.
48 Negative means not in a function or not using xcoff. */
50 static int xcoff_begin_function_line = -1;
51 static int xcoff_inlining = 0;
53 /* Name of the current include file. */
55 const char *xcoff_current_include_file;
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. */
62 static const char *xcoff_current_function_file;
64 /* Names of bss and data sections. These should be unique names for each
65 compilation unit. */
67 char *xcoff_bss_section_name;
68 char *xcoff_private_data_section_name;
69 char *xcoff_read_only_section_name;
71 /* Last source file name mentioned in a NOTE insn. */
73 const char *xcoff_lastfile;
75 /* Macro definitions used below. */
77 #define ABS_OR_RELATIVE_LINENO(LINENO) \
78 ((xcoff_inlining) ? (LINENO) : (LINENO) - xcoff_begin_function_line)
80 /* Output source line numbers via ".line". */
81 #define ASM_OUTPUT_LINE(FILE,LINENUM) \
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)
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); \
101 #define ASM_OUTPUT_LFE(FILE,LINENUM) \
102 do \
104 fprintf (FILE, "\t.ef\t%d\n", (LINENUM)); \
105 xcoff_begin_function_line = -1; \
107 while (0)
109 #define ASM_OUTPUT_LBB(FILE,LINENUM,BLOCKNUM) \
110 fprintf (FILE, "\t.bb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
112 #define ASM_OUTPUT_LBE(FILE,LINENUM,BLOCKNUM) \
113 fprintf (FILE, "\t.eb\t%d\n", ABS_OR_RELATIVE_LINENO (LINENUM))
115 static void xcoffout_block (tree, int, tree);
116 static void xcoffout_source_file (FILE *, const char *, int);
118 /* Support routines for XCOFF debugging info. */
120 struct xcoff_type_number
122 const char *name;
123 int number;
125 static const struct xcoff_type_number xcoff_type_numbers[] = {
126 { "int", -1 },
127 { "char", -2 },
128 { "short int", -3 },
129 { "long int", -4 }, /* fiddled to -31 if 64 bits */
130 { "unsigned char", -5 },
131 { "signed char", -6 },
132 { "short unsigned int", -7 },
133 { "unsigned int", -8 },
134 /* No such type "unsigned". */
135 { "long unsigned int", -10 }, /* fiddled to -32 if 64 bits */
136 { "void", -11 },
137 { "float", -12 },
138 { "double", -13 },
139 { "long double", -14 },
140 /* Pascal and Fortran types run from -15 to -29. */
141 { "wchar", -30 }, /* XXX Should be "wchar_t" ? */
142 { "long long int", -31 },
143 { "long long unsigned int", -32 },
144 /* Additional Fortran types run from -33 to -37. */
146 /* ??? Should also handle built-in C++ and Obj-C types. There perhaps
147 aren't any that C doesn't already have. */
150 /* Returns an XCOFF fundamental type number for DECL (assumed to be a
151 TYPE_DECL), or 0 if dbxout.c should assign a type number normally. */
153 xcoff_assign_fundamental_type_number (tree decl)
155 const char *name;
156 size_t i;
158 /* Do not waste time searching the list for non-intrinsic types. */
159 if (DECL_NAME (decl) == 0 || ! DECL_IS_BUILTIN (decl))
160 return 0;
162 name = IDENTIFIER_POINTER (DECL_NAME (decl));
164 /* Linear search, blech, but the list is too small to bother
165 doing anything else. */
166 for (i = 0; i < ARRAY_SIZE (xcoff_type_numbers); i++)
167 if (!strcmp (xcoff_type_numbers[i].name, name))
168 goto found;
169 return 0;
171 found:
172 /* -4 and -10 should be replaced with -31 and -32, respectively,
173 when used for a 64-bit type. */
174 if (int_size_in_bytes (TREE_TYPE (decl)) == 8)
176 if (xcoff_type_numbers[i].number == -4)
177 return -31;
178 if (xcoff_type_numbers[i].number == -10)
179 return -32;
181 return xcoff_type_numbers[i].number;
184 /* Print an error message for unrecognized stab codes. */
186 #define UNKNOWN_STAB(STR) \
187 internal_error ("no sclass for %s stab (0x%x)", STR, stab)
189 /* Conversion routine from BSD stabs to AIX storage classes. */
192 stab_to_sclass (int stab)
194 switch (stab)
196 case N_GSYM:
197 return C_GSYM;
199 case N_FNAME:
200 UNKNOWN_STAB ("N_FNAME");
202 case N_FUN:
203 return C_FUN;
205 case N_STSYM:
206 case N_LCSYM:
207 return C_STSYM;
209 case N_MAIN:
210 UNKNOWN_STAB ("N_MAIN");
212 case N_RSYM:
213 return C_RSYM;
215 case N_SSYM:
216 UNKNOWN_STAB ("N_SSYM");
218 case N_RPSYM:
219 return C_RPSYM;
221 case N_PSYM:
222 return C_PSYM;
223 case N_LSYM:
224 return C_LSYM;
225 case N_DECL:
226 return C_DECL;
227 case N_ENTRY:
228 return C_ENTRY;
230 case N_SO:
231 UNKNOWN_STAB ("N_SO");
233 case N_SOL:
234 UNKNOWN_STAB ("N_SOL");
236 case N_SLINE:
237 UNKNOWN_STAB ("N_SLINE");
239 case N_DSLINE:
240 UNKNOWN_STAB ("N_DSLINE");
242 case N_BSLINE:
243 UNKNOWN_STAB ("N_BSLINE");
245 case N_BINCL:
246 UNKNOWN_STAB ("N_BINCL");
248 case N_EINCL:
249 UNKNOWN_STAB ("N_EINCL");
251 case N_EXCL:
252 UNKNOWN_STAB ("N_EXCL");
254 case N_LBRAC:
255 UNKNOWN_STAB ("N_LBRAC");
257 case N_RBRAC:
258 UNKNOWN_STAB ("N_RBRAC");
260 case N_BCOMM:
261 return C_BCOMM;
262 case N_ECOMM:
263 return C_ECOMM;
264 case N_ECOML:
265 return C_ECOML;
267 case N_LENG:
268 UNKNOWN_STAB ("N_LENG");
270 case N_PC:
271 UNKNOWN_STAB ("N_PC");
273 case N_M2C:
274 UNKNOWN_STAB ("N_M2C");
276 case N_SCOPE:
277 UNKNOWN_STAB ("N_SCOPE");
279 case N_CATCH:
280 UNKNOWN_STAB ("N_CATCH");
282 case N_OPT:
283 UNKNOWN_STAB ("N_OPT");
285 default:
286 UNKNOWN_STAB ("?");
290 /* Output debugging info to FILE to switch to sourcefile FILENAME.
291 INLINE_P is true if this is from an inlined function. */
293 static void
294 xcoffout_source_file (FILE *file, const char *filename, int inline_p)
296 if (filename
297 && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
298 || (inline_p && ! xcoff_inlining)
299 || (! inline_p && xcoff_inlining)))
301 if (xcoff_current_include_file)
303 fprintf (file, "\t.ei\t");
304 output_quoted_string (file,
305 remap_debug_filename (xcoff_current_include_file));
306 fprintf (file, "\n");
307 xcoff_current_include_file = NULL;
309 xcoff_inlining = inline_p;
310 if (strcmp (main_input_filename, filename) || inline_p)
312 fprintf (file, "\t.bi\t");
313 output_quoted_string (file, remap_debug_filename (filename));
314 fprintf (file, "\n");
315 xcoff_current_include_file = filename;
317 xcoff_lastfile = filename;
321 /* Output a line number symbol entry for location (FILENAME, LINE). */
323 void
324 xcoffout_source_line (unsigned int line, const char *filename)
326 bool inline_p = (strcmp (xcoff_current_function_file, filename) != 0
327 || (int) line < xcoff_begin_function_line);
329 xcoffout_source_file (asm_out_file, filename, inline_p);
331 ASM_OUTPUT_LINE (asm_out_file, line);
334 /* Output the symbols defined in block number DO_BLOCK.
336 This function works by walking the tree structure of blocks,
337 counting blocks until it finds the desired block. */
339 static int do_block = 0;
341 static void
342 xcoffout_block (tree block, int depth, tree args)
344 while (block)
346 /* Ignore blocks never expanded or otherwise marked as real. */
347 if (TREE_USED (block))
349 /* When we reach the specified block, output its symbols. */
350 if (BLOCK_NUMBER (block) == do_block)
352 /* Output the syms of the block. */
353 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
354 dbxout_syms (BLOCK_VARS (block));
355 if (args)
356 dbxout_reg_parms (args);
358 /* We are now done with the block. Don't go to inner blocks. */
359 return;
361 /* If we are past the specified block, stop the scan. */
362 else if (BLOCK_NUMBER (block) >= do_block)
363 return;
365 /* Output the subblocks. */
366 xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
368 block = BLOCK_CHAIN (block);
372 /* Describe the beginning of an internal block within a function.
373 Also output descriptions of variables defined in this block.
375 N is the number of the block, by order of beginning, counting from 1,
376 and not counting the outermost (function top-level) block.
377 The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
378 if the count starts at 0 for the outermost one. */
380 void
381 xcoffout_begin_block (unsigned int line, unsigned int n)
383 tree decl = current_function_decl;
385 /* The IBM AIX compiler does not emit a .bb for the function level scope,
386 so we avoid it here also. */
387 if (n != 1)
388 ASM_OUTPUT_LBB (asm_out_file, line, n);
390 do_block = n;
391 xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
394 /* Describe the end line-number of an internal block within a function. */
396 void
397 xcoffout_end_block (unsigned int line, unsigned int n)
399 if (n != 1)
400 ASM_OUTPUT_LBE (asm_out_file, line, n);
403 /* Called at beginning of function (before prologue).
404 Declare function as needed for debugging. */
406 void
407 xcoffout_declare_function (FILE *file, tree decl, const char *name)
409 size_t len;
411 if (*name == '*')
412 name++;
413 len = strlen (name);
414 if (name[len - 1] == ']')
416 char *n = alloca (len - 3);
417 memcpy (n, name, len - 4);
418 n[len - 4] = '\0';
419 name = n;
422 /* Any pending .bi or .ei must occur before the .function pseudo op.
423 Otherwise debuggers will think that the function is in the previous
424 file and/or at the wrong line number. */
425 xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
426 dbxout_symbol (decl, 0);
428 /* .function NAME, TOP, MAPPING, TYPE, SIZE
429 16 and 044 are placeholders for backwards compatibility */
430 fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
431 name, name, name, name);
434 /* Called at beginning of function body (at start of prologue).
435 Record the function's starting line number, so we can output
436 relative line numbers for the other lines.
437 Record the file name that this function is contained in. */
439 void
440 xcoffout_begin_prologue (unsigned int line,
441 const char *file ATTRIBUTE_UNUSED)
443 ASM_OUTPUT_LFB (asm_out_file, line);
444 dbxout_parms (DECL_ARGUMENTS (current_function_decl));
446 /* Emit the symbols for the outermost BLOCK's variables. sdbout.c does this
447 in sdbout_begin_block, but there is no guarantee that there will be any
448 inner block 1, so we must do it here. This gives a result similar to
449 dbxout, so it does make some sense. */
450 do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
451 xcoffout_block (DECL_INITIAL (current_function_decl), 0,
452 DECL_ARGUMENTS (current_function_decl));
454 ASM_OUTPUT_LINE (asm_out_file, line);
457 /* Called at end of function (before epilogue).
458 Describe end of outermost block. */
460 void
461 xcoffout_end_function (unsigned int last_linenum)
463 ASM_OUTPUT_LFE (asm_out_file, last_linenum);
466 /* Output xcoff info for the absolute end of a function.
467 Called after the epilogue is output. */
469 void
470 xcoffout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
471 const char *file ATTRIBUTE_UNUSED)
473 /* We need to pass the correct function size to .function, otherwise,
474 the xas assembler can't figure out the correct size for the function
475 aux entry. So, we emit a label after the last instruction which can
476 be used by the .function pseudo op to calculate the function size. */
478 const char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
479 if (*fname == '*')
480 ++fname;
481 fprintf (asm_out_file, "FE..");
482 ASM_OUTPUT_LABEL (asm_out_file, fname);
484 #endif /* XCOFF_DEBUGGING_INFO */