OSDN Git Service

* basic-block.h (struct basic_block_def): Add discriminator field.
[pf3gnuchains/gcc-fork.git] / gcc / xcoffout.c
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, 2008  Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
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.
11
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.
16
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/>.  */
20
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.  */
25
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"
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
50 static int xcoff_begin_function_line = -1;
51 static int xcoff_inlining = 0;
52
53 /* Name of the current include file.  */
54
55 const 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
62 static 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
67 char *xcoff_bss_section_name;
68 char *xcoff_private_data_section_name;
69 char *xcoff_read_only_section_name;
70
71 /* Last source file name mentioned in a NOTE insn.  */
72
73 const 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".  */
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)
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
115 static void xcoffout_block (tree, int, tree);
116 static void xcoffout_source_file (FILE *, const char *, int);
117 \f
118 /* Support routines for XCOFF debugging info.  */
119
120 struct xcoff_type_number
121 {
122   const char *name;
123   int number;
124 };
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.  */
145
146   /* ??? Should also handle built-in C++ and Obj-C types.  There perhaps
147      aren't any that C doesn't already have.  */
148 };    
149
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.  */
152 int
153 xcoff_assign_fundamental_type_number (tree decl)
154 {
155   const char *name;
156   size_t i;
157
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;
161
162   name = IDENTIFIER_POINTER (DECL_NAME (decl));
163
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;
170
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)
175     {
176       if (xcoff_type_numbers[i].number == -4)
177         return -31;
178       if (xcoff_type_numbers[i].number == -10)
179         return -32;
180     }
181   return xcoff_type_numbers[i].number;
182 }
183
184 /* Print an error message for unrecognized stab codes.  */
185
186 #define UNKNOWN_STAB(STR)       \
187   internal_error ("no sclass for %s stab (0x%x)", STR, stab)
188
189 /* Conversion routine from BSD stabs to AIX storage classes.  */
190
191 int
192 stab_to_sclass (int stab)
193 {
194   switch (stab)
195     {
196     case N_GSYM:
197       return C_GSYM;
198
199     case N_FNAME:
200       UNKNOWN_STAB ("N_FNAME");
201
202     case N_FUN:
203       return C_FUN;
204
205     case N_STSYM:
206     case N_LCSYM:
207       return C_STSYM;
208
209     case N_MAIN:
210       UNKNOWN_STAB ("N_MAIN");
211
212     case N_RSYM:
213       return C_RSYM;
214
215     case N_SSYM:
216       UNKNOWN_STAB ("N_SSYM");
217
218     case N_RPSYM:
219       return C_RPSYM;
220
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;
229
230     case N_SO:
231       UNKNOWN_STAB ("N_SO");
232
233     case N_SOL:
234       UNKNOWN_STAB ("N_SOL");
235
236     case N_SLINE:
237       UNKNOWN_STAB ("N_SLINE");
238
239     case N_DSLINE:
240       UNKNOWN_STAB ("N_DSLINE");
241
242     case N_BSLINE:
243       UNKNOWN_STAB ("N_BSLINE");
244
245     case N_BINCL:
246       UNKNOWN_STAB ("N_BINCL");
247
248     case N_EINCL:
249       UNKNOWN_STAB ("N_EINCL");
250
251     case N_EXCL:
252       UNKNOWN_STAB ("N_EXCL");
253
254     case N_LBRAC:
255       UNKNOWN_STAB ("N_LBRAC");
256
257     case N_RBRAC:
258       UNKNOWN_STAB ("N_RBRAC");
259
260     case N_BCOMM:
261       return C_BCOMM;
262     case N_ECOMM:
263       return C_ECOMM;
264     case N_ECOML:
265       return C_ECOML;
266
267     case N_LENG:
268       UNKNOWN_STAB ("N_LENG");
269
270     case N_PC:
271       UNKNOWN_STAB ("N_PC");
272
273     case N_M2C:
274       UNKNOWN_STAB ("N_M2C");
275
276     case N_SCOPE:
277       UNKNOWN_STAB ("N_SCOPE");
278
279     case N_CATCH:
280       UNKNOWN_STAB ("N_CATCH");
281
282     case N_OPT:
283       UNKNOWN_STAB ("N_OPT");
284
285     default:
286       UNKNOWN_STAB ("?");
287     }
288 }
289 \f
290 /* Output debugging info to FILE to switch to sourcefile FILENAME.
291    INLINE_P is true if this is from an inlined function.  */
292
293 static void
294 xcoffout_source_file (FILE *file, const char *filename, int inline_p)
295 {
296   if (filename
297       && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
298           || (inline_p && ! xcoff_inlining)
299           || (! inline_p && xcoff_inlining)))
300     {
301       if (xcoff_current_include_file)
302         {
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;
308         }
309       xcoff_inlining = inline_p;
310       if (strcmp (main_input_filename, filename) || inline_p)
311         {
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;
316         }
317       xcoff_lastfile = filename;
318     }
319 }
320
321 /* Output a line number symbol entry for location (FILENAME, LINE).  */
322
323 void
324 xcoffout_source_line (unsigned int line, const char *filename,
325                       int discriminator ATTRIBUTE_UNUSED)
326 {
327   bool inline_p = (strcmp (xcoff_current_function_file, filename) != 0
328                    || (int) line < xcoff_begin_function_line);
329
330   xcoffout_source_file (asm_out_file, filename, inline_p);
331
332   ASM_OUTPUT_LINE (asm_out_file, line);
333 }
334 \f
335 /* Output the symbols defined in block number DO_BLOCK.
336
337    This function works by walking the tree structure of blocks,
338    counting blocks until it finds the desired block.  */
339
340 static int do_block = 0;
341
342 static void
343 xcoffout_block (tree block, int depth, tree args)
344 {
345   while (block)
346     {
347       /* Ignore blocks never expanded or otherwise marked as real.  */
348       if (TREE_USED (block))
349         {
350           /* When we reach the specified block, output its symbols.  */
351           if (BLOCK_NUMBER (block) == do_block)
352             {
353               /* Output the syms of the block.  */
354               if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
355                 dbxout_syms (BLOCK_VARS (block));
356               if (args)
357                 dbxout_reg_parms (args);
358
359               /* We are now done with the block.  Don't go to inner blocks.  */
360               return;
361             }
362           /* If we are past the specified block, stop the scan.  */
363           else if (BLOCK_NUMBER (block) >= do_block)
364             return;
365
366           /* Output the subblocks.  */
367           xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
368         }
369       block = BLOCK_CHAIN (block);
370     }
371 }
372
373 /* Describe the beginning of an internal block within a function.
374    Also output descriptions of variables defined in this block.
375
376    N is the number of the block, by order of beginning, counting from 1,
377    and not counting the outermost (function top-level) block.
378    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
379    if the count starts at 0 for the outermost one.  */
380
381 void
382 xcoffout_begin_block (unsigned int line, unsigned int n)
383 {
384   tree decl = current_function_decl;
385
386   /* The IBM AIX compiler does not emit a .bb for the function level scope,
387      so we avoid it here also.  */
388   if (n != 1)
389     ASM_OUTPUT_LBB (asm_out_file, line, n);
390
391   do_block = n;
392   xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
393 }
394
395 /* Describe the end line-number of an internal block within a function.  */
396
397 void
398 xcoffout_end_block (unsigned int line, unsigned int n)
399 {
400   if (n != 1)
401     ASM_OUTPUT_LBE (asm_out_file, line, n);
402 }
403
404 /* Called at beginning of function (before prologue).
405    Declare function as needed for debugging.  */
406
407 void
408 xcoffout_declare_function (FILE *file, tree decl, const char *name)
409 {
410   size_t len;
411
412   if (*name == '*')
413     name++;
414   len = strlen (name);
415   if (name[len - 1] == ']')
416     {
417       char *n = XALLOCAVEC (char, len - 3);
418       memcpy (n, name, len - 4);
419       n[len - 4] = '\0';
420       name = n;
421     }
422
423   /* Any pending .bi or .ei must occur before the .function pseudo op.
424      Otherwise debuggers will think that the function is in the previous
425      file and/or at the wrong line number.  */
426   xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
427   dbxout_symbol (decl, 0);
428
429   /* .function NAME, TOP, MAPPING, TYPE, SIZE
430      16 and 044 are placeholders for backwards compatibility */
431   fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
432            name, name, name, name);
433 }
434
435 /* Called at beginning of function body (at start of prologue).
436    Record the function's starting line number, so we can output
437    relative line numbers for the other lines.
438    Record the file name that this function is contained in.  */
439
440 void
441 xcoffout_begin_prologue (unsigned int line,
442                          const char *file ATTRIBUTE_UNUSED)
443 {
444   ASM_OUTPUT_LFB (asm_out_file, line);
445   dbxout_parms (DECL_ARGUMENTS (current_function_decl));
446
447   /* Emit the symbols for the outermost BLOCK's variables.  sdbout.c does this
448      in sdbout_begin_block, but there is no guarantee that there will be any
449      inner block 1, so we must do it here.  This gives a result similar to
450      dbxout, so it does make some sense.  */
451   do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
452   xcoffout_block (DECL_INITIAL (current_function_decl), 0,
453                   DECL_ARGUMENTS (current_function_decl));
454
455   ASM_OUTPUT_LINE (asm_out_file, line);
456 }
457
458 /* Called at end of function (before epilogue).
459    Describe end of outermost block.  */
460
461 void
462 xcoffout_end_function (unsigned int last_linenum)
463 {
464   ASM_OUTPUT_LFE (asm_out_file, last_linenum);
465 }
466
467 /* Output xcoff info for the absolute end of a function.
468    Called after the epilogue is output.  */
469
470 void
471 xcoffout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
472                        const char *file ATTRIBUTE_UNUSED)
473 {
474   /* We need to pass the correct function size to .function, otherwise,
475      the xas assembler can't figure out the correct size for the function
476      aux entry.  So, we emit a label after the last instruction which can
477      be used by the .function pseudo op to calculate the function size.  */
478
479   const char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
480   if (*fname == '*')
481     ++fname;
482   fprintf (asm_out_file, "FE..");
483   ASM_OUTPUT_LABEL (asm_out_file, fname);
484 }
485 #endif /* XCOFF_DEBUGGING_INFO */