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                       bool is_stmt ATTRIBUTE_UNUSED)
 327 {
 328   bool inline_p = (strcmp (xcoff_current_function_file, filename) != 0
 329                    || (int) line < xcoff_begin_function_line);
 330
 331   xcoffout_source_file (asm_out_file, filename, inline_p);
 332
 333   ASM_OUTPUT_LINE (asm_out_file, line);
 334 }
 335 \f
 336 /* Output the symbols defined in block number DO_BLOCK.
 337
 338    This function works by walking the tree structure of blocks,
 339    counting blocks until it finds the desired block.  */
 340
 341 static int do_block = 0;
 342
 343 static void
 344 xcoffout_block (tree block, int depth, tree args)
 345 {
 346   while (block)
 347     {
 348       /* Ignore blocks never expanded or otherwise marked as real.  */
 349       if (TREE_USED (block))
 350         {
 351           /* When we reach the specified block, output its symbols.  */
 352           if (BLOCK_NUMBER (block) == do_block)
 353             {
 354               /* Output the syms of the block.  */
 355               if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
 356                 dbxout_syms (BLOCK_VARS (block));
 357               if (args)
 358                 dbxout_reg_parms (args);
 359
 360               /* We are now done with the block.  Don't go to inner blocks.  */
 361               return;
 362             }
 363           /* If we are past the specified block, stop the scan.  */
 364           else if (BLOCK_NUMBER (block) >= do_block)
 365             return;
 366
 367           /* Output the subblocks.  */
 368           xcoffout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
 369         }
 370       block = BLOCK_CHAIN (block);
 371     }
 372 }
 373
 374 /* Describe the beginning of an internal block within a function.
 375    Also output descriptions of variables defined in this block.
 376
 377    N is the number of the block, by order of beginning, counting from 1,
 378    and not counting the outermost (function top-level) block.
 379    The blocks match the BLOCKs in DECL_INITIAL (current_function_decl),
 380    if the count starts at 0 for the outermost one.  */
 381
 382 void
 383 xcoffout_begin_block (unsigned int line, unsigned int n)
 384 {
 385   tree decl = current_function_decl;
 386
 387   /* The IBM AIX compiler does not emit a .bb for the function level scope,
 388      so we avoid it here also.  */
 389   if (n != 1)
 390     ASM_OUTPUT_LBB (asm_out_file, line, n);
 391
 392   do_block = n;
 393   xcoffout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
 394 }
 395
 396 /* Describe the end line-number of an internal block within a function.  */
 397
 398 void
 399 xcoffout_end_block (unsigned int line, unsigned int n)
 400 {
 401   if (n != 1)
 402     ASM_OUTPUT_LBE (asm_out_file, line, n);
 403 }
 404
 405 /* Called at beginning of function (before prologue).
 406    Declare function as needed for debugging.  */
 407
 408 void
 409 xcoffout_declare_function (FILE *file, tree decl, const char *name)
 410 {
 411   size_t len;
 412
 413   if (*name == '*')
 414     name++;
 415   len = strlen (name);
 416   if (name[len - 1] == ']')
 417     {
 418       char *n = XALLOCAVEC (char, len - 3);
 419       memcpy (n, name, len - 4);
 420       n[len - 4] = '\0';
 421       name = n;
 422     }
 423
 424   /* Any pending .bi or .ei must occur before the .function pseudo op.
 425      Otherwise debuggers will think that the function is in the previous
 426      file and/or at the wrong line number.  */
 427   xcoffout_source_file (file, DECL_SOURCE_FILE (decl), 0);
 428   dbxout_symbol (decl, 0);
 429
 430   /* .function NAME, TOP, MAPPING, TYPE, SIZE
 431      16 and 044 are placeholders for backwards compatibility */
 432   fprintf (file, "\t.function .%s,.%s,16,044,FE..%s-.%s\n",
 433            name, name, name, name);
 434 }
 435
 436 /* Called at beginning of function body (at start of prologue).
 437    Record the function's starting line number, so we can output
 438    relative line numbers for the other lines.
 439    Record the file name that this function is contained in.  */
 440
 441 void
 442 xcoffout_begin_prologue (unsigned int line,
 443                          const char *file ATTRIBUTE_UNUSED)
 444 {
 445   ASM_OUTPUT_LFB (asm_out_file, line);
 446   dbxout_parms (DECL_ARGUMENTS (current_function_decl));
 447
 448   /* Emit the symbols for the outermost BLOCK's variables.  sdbout.c does this
 449      in sdbout_begin_block, but there is no guarantee that there will be any
 450      inner block 1, so we must do it here.  This gives a result similar to
 451      dbxout, so it does make some sense.  */
 452   do_block = BLOCK_NUMBER (DECL_INITIAL (current_function_decl));
 453   xcoffout_block (DECL_INITIAL (current_function_decl), 0,
 454                   DECL_ARGUMENTS (current_function_decl));
 455
 456   ASM_OUTPUT_LINE (asm_out_file, line);
 457 }
 458
 459 /* Called at end of function (before epilogue).
 460    Describe end of outermost block.  */
 461
 462 void
 463 xcoffout_end_function (unsigned int last_linenum)
 464 {
 465   ASM_OUTPUT_LFE (asm_out_file, last_linenum);
 466 }
 467
 468 /* Output xcoff info for the absolute end of a function.
 469    Called after the epilogue is output.  */
 470
 471 void
 472 xcoffout_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
 473                        const char *file ATTRIBUTE_UNUSED)
 474 {
 475   /* We need to pass the correct function size to .function, otherwise,
 476      the xas assembler can't figure out the correct size for the function
 477      aux entry.  So, we emit a label after the last instruction which can
 478      be used by the .function pseudo op to calculate the function size.  */
 479
 480   const char *fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
 481   if (*fname == '*')
 482     ++fname;
 483   fprintf (asm_out_file, "FE..");
 484   ASM_OUTPUT_LABEL (asm_out_file, fname);
 485 }
 486 #endif /* XCOFF_DEBUGGING_INFO */