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
   3    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 2, 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 COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-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
  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" 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
 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 = IDENTIFIER_POINTER (DECL_NAME (decl));
 156   size_t i;
 157
 158   /* Do not waste time searching the list for non-intrinsic types.  */
 159   if (DECL_SOURCE_LINE (decl) > 0)
 160     return 0;
 161
 162   /* Linear search, blech, but the list is too small to bother
 163      doing anything else.  */
 164   for (i = 0; i < ARRAY_SIZE (xcoff_type_numbers); i++)
 165     if (!strcmp (xcoff_type_numbers[i].name, name))
 166       goto found;
 167   return 0;
 168
 169  found:
 170   /* -4 and -10 should be replaced with -31 and -32, respectively,
 171      when used for a 64-bit type.  */
 172   if (int_size_in_bytes (TREE_TYPE (decl)) == 8)
 173     {
 174       if (xcoff_type_numbers[i].number == -4)
 175         return -31;
 176       if (xcoff_type_numbers[i].number == -10)
 177         return -32;
 178     }
 179   return xcoff_type_numbers[i].number;
 180 }
 181
 182 /* Print an error message for unrecognized stab codes.  */
 183
 184 #define UNKNOWN_STAB(STR)       \
 185   internal_error ("no sclass for %s stab (0x%x)\n", STR, stab)
 186
 187 /* Conversion routine from BSD stabs to AIX storage classes.  */
 188
 189 int
 190 stab_to_sclass (int stab)
 191 {
 192   switch (stab)
 193     {
 194     case N_GSYM:
 195       return C_GSYM;
 196
 197     case N_FNAME:
 198       UNKNOWN_STAB ("N_FNAME");
 199
 200     case N_FUN:
 201       return C_FUN;
 202
 203     case N_STSYM:
 204     case N_LCSYM:
 205       return C_STSYM;
 206
 207     case N_MAIN:
 208       UNKNOWN_STAB ("N_MAIN");
 209
 210     case N_RSYM:
 211       return C_RSYM;
 212
 213     case N_SSYM:
 214       UNKNOWN_STAB ("N_SSYM");
 215
 216     case N_RPSYM:
 217       return C_RPSYM;
 218
 219     case N_PSYM:
 220       return C_PSYM;
 221     case N_LSYM:
 222       return C_LSYM;
 223     case N_DECL:
 224       return C_DECL;
 225     case N_ENTRY:
 226       return C_ENTRY;
 227
 228     case N_SO:
 229       UNKNOWN_STAB ("N_SO");
 230
 231     case N_SOL:
 232       UNKNOWN_STAB ("N_SOL");
 233
 234     case N_SLINE:
 235       UNKNOWN_STAB ("N_SLINE");
 236
 237     case N_DSLINE:
 238       UNKNOWN_STAB ("N_DSLINE");
 239
 240     case N_BSLINE:
 241       UNKNOWN_STAB ("N_BSLINE");
 242
 243     case N_BINCL:
 244       UNKNOWN_STAB ("N_BINCL");
 245
 246     case N_EINCL:
 247       UNKNOWN_STAB ("N_EINCL");
 248
 249     case N_EXCL:
 250       UNKNOWN_STAB ("N_EXCL");
 251
 252     case N_LBRAC:
 253       UNKNOWN_STAB ("N_LBRAC");
 254
 255     case N_RBRAC:
 256       UNKNOWN_STAB ("N_RBRAC");
 257
 258     case N_BCOMM:
 259       return C_BCOMM;
 260     case N_ECOMM:
 261       return C_ECOMM;
 262     case N_ECOML:
 263       return C_ECOML;
 264
 265     case N_LENG:
 266       UNKNOWN_STAB ("N_LENG");
 267
 268     case N_PC:
 269       UNKNOWN_STAB ("N_PC");
 270
 271     case N_M2C:
 272       UNKNOWN_STAB ("N_M2C");
 273
 274     case N_SCOPE:
 275       UNKNOWN_STAB ("N_SCOPE");
 276
 277     case N_CATCH:
 278       UNKNOWN_STAB ("N_CATCH");
 279
 280     case N_OPT:
 281       UNKNOWN_STAB ("N_OPT");
 282
 283     default:
 284       UNKNOWN_STAB ("?");
 285     }
 286 }
 287 \f
 288 /* Output debugging info to FILE to switch to sourcefile FILENAME.
 289    INLINE_P is true if this is from an inlined function.  */
 290
 291 static void
 292 xcoffout_source_file (FILE *file, const char *filename, int inline_p)
 293 {
 294   if (filename
 295       && (xcoff_lastfile == 0 || strcmp (filename, xcoff_lastfile)
 296           || (inline_p && ! xcoff_inlining)
 297           || (! inline_p && xcoff_inlining)))
 298     {
 299       if (xcoff_current_include_file)
 300         {
 301           fprintf (file, "\t.ei\t");
 302           output_quoted_string (file, xcoff_current_include_file);
 303           fprintf (file, "\n");
 304           xcoff_current_include_file = NULL;
 305         }
 306       xcoff_inlining = inline_p;
 307       if (strcmp (main_input_filename, filename) || inline_p)
 308         {
 309           fprintf (file, "\t.bi\t");
 310           output_quoted_string (file, filename);
 311           fprintf (file, "\n");
 312           xcoff_current_include_file = filename;
 313         }
 314       xcoff_lastfile = filename;
 315     }
 316 }
 317
 318 /* Output a line number symbol entry for location (FILENAME, LINE).  */
 319
 320 void
 321 xcoffout_source_line (unsigned int line, const char *filename)
 322 {
 323   bool inline_p = (strcmp (xcoff_current_function_file, filename) != 0
 324                    || (int) line < xcoff_begin_function_line);
 325
 326   xcoffout_source_file (asm_out_file, filename, inline_p);
 327
 328   ASM_OUTPUT_SOURCE_LINE (asm_out_file, line, 0);
 329 }
 330 \f
 331 /* Output the symbols defined in block number DO_BLOCK.
 332
 333    This function works by walking the tree structure of blocks,
 334    counting blocks until it finds the desired block.  */
 335
 336 static int do_block = 0;
 337
 338 static void
 339 xcoffout_block (tree block, int depth, tree args)
 340 {
 341   while (block)
 342     {
 343       /* Ignore blocks never expanded or otherwise marked as real.  */
 344       if (TREE_USED (block))
 345         {
 346           /* When we reach the specified block, output its symbols.  */
 347           if (BLOCK_NUMBER (block) == do_block)
 348             {
 349               /* Output the syms of the block.  */
 350               if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
 351                 dbxout_syms (BLOCK_VARS (block));
 352               if (args)
 353                 dbxout_reg_parms (args);
 354
 355               /* We are now done with the block.  Don't go to inner blocks.  */
 356               return;
 357             }
 358           /* If we are past the specified block, stop the scan.  */
 359           else if (BLOCK_NUMBER (block) >= do_block)
 360             return;
 361
 362           /* Output the subblocks.  */
 363           xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
 364         }
 365       block = BLOCK_CHAIN (block);
 366     }
 367 }
 368
 369 /* Describe the beginning of an internal block within a function.
 370    Also output descriptions of variables defined in this block.
 371
 372    N is the number of the block, by order of beginning, counting from 1,
 373    and not counting the outermost (function top-level) block.
 374    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
 375    if the count starts at 0 for the outermost one.  */
 376
 377 void
 378 xcoffout_begin_block (unsigned int line, unsigned int n)
 379 {
 380   tree decl = current_function_decl;
 381
 382   /* The IBM AIX compiler does not emit a .bb for the function level scope,
 383      so we avoid it here also.  */
 384   if (n != 1)
 385     ASM_OUTPUT_LBB (asm_out_file, line, n);
 386
 387   do_block = n;
 388   xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
 389 }
 390
 391 /* Describe the end line-number of an internal block within a function.  */
 392
 393 void
 394 xcoffout_end_block (unsigned int line, unsigned int n)
 395 {
 396   if (n != 1)
 397     ASM_OUTPUT_LBE (asm_out_file, line, n);
 398 }
 399
 400 /* Called at beginning of function (before prologue).
 401    Declare function as needed for debugging.  */
 402
 403 void
 404 xcoffout_declare_function (FILE *file, tree decl, const char *name)
 405 {
 406   int i;
 407
 408   if (*name == '*')
 409     name++;
 410   else
 411     for (i = 0; name[i]; ++i)
 412       {
 413         if (name[i] == '[')
 414           {
 415             char *n = alloca (i + 1);
 416             strncpy (n, name, i);
 417             n[i] = '\0';
 418             name = n;
 419             break;
 420           }
 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_SOURCE_LINE (asm_out_file, line, 0);
 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 */